dymokomi/luce-cad
Source of release 0.9.5
0.9.5 / src / brep / codec.lucb
## A B-rep in a geometry file (geocore's prism codec): element `brep` with the
## tolerances and every column as it is stored, so a load gives back the same
## model bit for bit; face paths and names are each one byte column split by
## offsets.
## Derived data (records, caches, tessellations) is never written. The
## writer borrows the stores' bytes until the file is written.
## Every column of `model` under element `path`.
pub func encode_brep(model: const BrepModel*, writer: GeometryWriter*, path: str) -> !:
try writer.crate.element(path, "brep")
try writer.crate.number("positional", model.tolerances.positional)
try writer.crate.number("fit", model.tolerances.fit)
try writer.crate.number("tangent", model.tolerances.tangent)
try writer.crate.number("curvature", model.tolerances.curvature)
try put[Vector3](writer, "vertices", dtype_float64, 3, &model.vertices)
try put[u8](writer, "curve_kind", dtype_uint8, 1, &model.curve_kind)
try put[i32](writer, "curve_ends", dtype_int32, 2, &model.curve_ends)
try put[f64](writer, "curve_frame", dtype_float64, curve_stride, &model.curve_frame)
try put[i32](writer, "curve_degree", dtype_int32, 1, &model.curve_degree)
try put[u8](writer, "curve_sense", dtype_uint8, 1, &model.curve_sense)
try put[i32](writer, "curve_point_offsets", dtype_int32, 1, &model.curve_point_offsets)
try put[Vector3](writer, "curve_points", dtype_float64, 3, &model.curve_points)
try put[i32](writer, "curve_weight_offsets", dtype_int32, 1, &model.curve_weight_offsets)
try put[f64](writer, "curve_weights", dtype_float64, 1, &model.curve_weights)
try put[i32](writer, "curve_knot_offsets", dtype_int32, 1, &model.curve_knot_offsets)
try put[f64](writer, "curve_knots", dtype_float64, 1, &model.curve_knots)
try put[f64](writer, "edge_precision", dtype_float64, 1, &model.edge_precision)
try put[f64](writer, "vertex_precision", dtype_float64, 1, &model.vertex_precision)
try put[u8](writer, "surface_kind", dtype_uint8, 1, &model.surface_kind)
try put[u8](writer, "surface_edited", dtype_uint8, 1, &model.surface_edited)
try put[f64](writer, "surface_frame", dtype_float64, surface_stride, &model.surface_frame)
try put[i32](writer, "surface_dims", dtype_int32, 4, &model.surface_dims)
try put[i32](writer, "surface_cv_offsets", dtype_int32, 1, &model.surface_cv_offsets)
try put[Vector3](writer, "cv_positions", dtype_float64, 3, &model.cv_positions)
try put[i32](writer, "surface_weight_offsets", dtype_int32, 1, &model.surface_weight_offsets)
try put[f64](writer, "cv_weights", dtype_float64, 1, &model.cv_weights)
try put[i32](writer, "surface_knot_offsets", dtype_int32, 1, &model.surface_knot_offsets)
try put[f64](writer, "surface_knots", dtype_float64, 1, &model.surface_knots)
try put[i32](writer, "face_surface", dtype_int32, 1, &model.face_surface)
try put[u8](writer, "face_sense", dtype_uint8, 1, &model.face_sense)
try put[i32](writer, "face_use_offsets", dtype_int32, 1, &model.face_use_offsets)
try put[i32](writer, "face_uses", dtype_int32, 1, &model.face_uses)
try put[i32](writer, "face_loop_offsets", dtype_int32, 1, &model.face_loop_offsets)
try put[i32](writer, "loop_sizes", dtype_int32, 1, &model.loop_sizes)
try put[Matrix4](writer, "face_placement", dtype_float64, 12, &model.face_placement)
try put[Vector3](writer, "face_color", dtype_float64, 3, &model.face_color)
try put[u8](writer, "face_colored", dtype_uint8, 1, &model.face_colored)
# Face paths and names: their bytes, split by offsets. The writer
# borrows array bytes until the file is written; these are temporary,
# so they are copied.
try put_texts(writer, "path_bytes", "path_offsets", &model.face_paths)
try put_texts(writer, "name_bytes", "name_offsets", &model.face_names)
func put_texts(writer: GeometryWriter*, bytes_name: str, offsets_name: str, texts: const FaceTexts*) -> !:
var bytes = Growing[u8]()
defer bytes.close()
var offsets = Growing[i32]()
defer offsets.close()
try texts.pack(&bytes, &offsets)
try writer.crate.copied_array(bytes_name, dtype_uint8, bytes.count, bytes.view())
try writer.crate.copied_array(offsets_name, dtype_int32, offsets.count, u8[]((u8*)offsets.items.data, offsets.count * 4))
func put[T](writer: GeometryWriter*, name: str, dtype: u8, columns: usize, store: const Store[T]*) -> !:
let values = store.view()
let component: usize = 8 if dtype == dtype_float64 else (4 if dtype == dtype_int32 else 1)
let rows = values.length * memory.size_of(T) // (columns * component)
try writer.column(name, dtype, rows, columns, u8[]((u8*)values.data, values.length * memory.size_of(T)))
## A B-rep read back from element `path`'s properties.
pub func decode_brep(reader: GeometryReader*, path: str) -> interop.Reference[BrepModel]!:
_ = path
var tolerances = CadTolerances()
var model_owner: interop.Reference[BrepModel]? = none
defer:
if let made = model_owner: made.release()
var path_bytes: Column[u8]
defer path_bytes.release()
var path_offsets: Column[i32]
defer path_offsets.release()
var name_bytes: Column[u8]
defer name_bytes.release()
var name_offsets: Column[i32]
defer name_offsets.release()
# The tolerances come first; the model is made when they are known.
while let header = try reader.next_property():
let name = header.name
if name == "positional" or name == "fit" or name == "tangent" or name == "curvature":
var value = try reader.column[f64](header)
defer value.release()
if value.count() == 1:
let number = value.view()[0]
if name == "positional": tolerances.positional = number
elif name == "fit": tolerances.fit = number
elif name == "tangent": tolerances.tangent = number
else: tolerances.curvature = number
continue
if model_owner == none:
model_owner = try BrepModel.held(tolerances)
let model = (model_owner else error(invalid, "a saved B-rep lost its model")).value()
let label = base_name(name)
if label == "path_bytes": path_bytes = try reader.column[u8](header)
elif label == "path_offsets": path_offsets = try reader.column[i32](header)
elif label == "name_bytes": name_bytes = try reader.column[u8](header)
elif label == "name_offsets": name_offsets = try reader.column[i32](header)
else: try read_store(reader, header, label, model)
let owner = model_owner else error(invalid, "a saved B-rep has no columns")
let model = owner.value()
model.changed()
if model.surface_edited.count != model.surface_kind.count: error(invalid, "a saved B-rep's surface columns do not match")
# A file with no precision columns has exact edges and vertices.
if model.edge_precision.count == 0: try model.edge_precision.fill(model.curve_kind.count, 0.0)
if model.vertex_precision.count == 0: try model.vertex_precision.fill(model.vertices.count, 0.0)
if model.edge_precision.count != model.curve_kind.count or model.vertex_precision.count != model.vertices.count: error(invalid, "a saved B-rep's precision columns do not match")
# Paths and names, one per face.
let faces = (usize)model.face_count()
try model.face_paths.unpack(path_bytes.view(), path_offsets.view(), faces)
try model.face_names.unpack(name_bytes.view(), name_offsets.view(), faces)
model_owner = none
return owner
## `name` without a `_chunks` suffix.
func base_name(name: str) -> str:
let bytes = name.bytes
if bytes.length > 7 and (str)bytes[bytes.length - 7..] == "_chunks": return (str)bytes[..<bytes.length - 7]
return name
## Read one column into the store it names.
func read_store(reader: GeometryReader*, header: PropertyHeader, label: str, model: BrepModel*) -> !:
if label == "vertices": try take[Vector3](reader, header, &model.vertices)
elif label == "curve_kind": try take[u8](reader, header, &model.curve_kind)
elif label == "curve_ends": try take[i32](reader, header, &model.curve_ends)
elif label == "curve_frame": try take[f64](reader, header, &model.curve_frame)
elif label == "curve_degree": try take[i32](reader, header, &model.curve_degree)
elif label == "curve_sense": try take[u8](reader, header, &model.curve_sense)
elif label == "curve_point_offsets": try take[i32](reader, header, &model.curve_point_offsets)
elif label == "curve_points": try take[Vector3](reader, header, &model.curve_points)
elif label == "curve_weight_offsets": try take[i32](reader, header, &model.curve_weight_offsets)
elif label == "curve_weights": try take[f64](reader, header, &model.curve_weights)
elif label == "curve_knot_offsets": try take[i32](reader, header, &model.curve_knot_offsets)
elif label == "curve_knots": try take[f64](reader, header, &model.curve_knots)
elif label == "edge_precision": try take[f64](reader, header, &model.edge_precision)
elif label == "vertex_precision": try take[f64](reader, header, &model.vertex_precision)
elif label == "surface_kind": try take[u8](reader, header, &model.surface_kind)
elif label == "surface_edited": try take[u8](reader, header, &model.surface_edited)
elif label == "surface_frame": try take[f64](reader, header, &model.surface_frame)
elif label == "surface_dims": try take[i32](reader, header, &model.surface_dims)
elif label == "surface_cv_offsets": try take[i32](reader, header, &model.surface_cv_offsets)
elif label == "cv_positions": try take[Vector3](reader, header, &model.cv_positions)
elif label == "surface_weight_offsets": try take[i32](reader, header, &model.surface_weight_offsets)
elif label == "cv_weights": try take[f64](reader, header, &model.cv_weights)
elif label == "surface_knot_offsets": try take[i32](reader, header, &model.surface_knot_offsets)
elif label == "surface_knots": try take[f64](reader, header, &model.surface_knots)
elif label == "face_surface": try take[i32](reader, header, &model.face_surface)
elif label == "face_sense": try take[u8](reader, header, &model.face_sense)
elif label == "face_use_offsets": try take[i32](reader, header, &model.face_use_offsets)
elif label == "face_uses": try take[i32](reader, header, &model.face_uses)
elif label == "face_loop_offsets": try take[i32](reader, header, &model.face_loop_offsets)
elif label == "loop_sizes": try take[i32](reader, header, &model.loop_sizes)
elif label == "face_placement": try take[Matrix4](reader, header, &model.face_placement)
elif label == "face_color": try take[Vector3](reader, header, &model.face_color)
elif label == "face_colored": try take[u8](reader, header, &model.face_colored)
func take[T](reader: GeometryReader*, header: PropertyHeader, store: Store[T]*) -> !:
var column = try reader.column[T](header)
store.close()
store.count = column.count()
store.column = column.take()