///|
/// Bridges between `gmlewis/step/components/*` and `gmlewis/cad`.
///
/// The STEP component packages model hardware primitives at three explicit
/// levels of detail. This file imports those primitives into the CAD / URDF
/// world: it parses CLI detail and thread options, and it converts a
/// `@step_common.Component` into `BodyPart`s and a `Component`.
///|
/// Parses a detail-level option.
///
/// Accepts `"simplified"`, `"detailed"`, `"fully-modeled"`, `"fully_modeled"`,
/// and `"full"`; returns `None` for anything else.
pub fn parse_detail_level(text : String) -> @step_common.DetailLevel? {
match text {
"simplified" | "simple" => Some(@step_common.DetailLevel::Simplified)
"detailed" | "detail" => Some(@step_common.DetailLevel::Detailed)
"fully-modeled" | "fully_modeled" | "full" =>
Some(@step_common.DetailLevel::FullyModeled)
_ => None
}
}
///|
/// Parses a thread-representation option.
///
/// Accepts `"none"`, `"cosmetic"`, and `"helical"`; returns `None` for
/// anything else.
pub fn parse_thread_rep(text : String) -> @step_common.ThreadRepresentation? {
match text {
"none" | "" => Some(@step_common.ThreadRepresentation::None)
"cosmetic" => Some(@step_common.ThreadRepresentation::Cosmetic)
"helical" => Some(@step_common.ThreadRepresentation::Helical)
_ => None
}
}
///|
/// The canonical CLI name of a detail level.
pub fn detail_level_name(level : @step_common.DetailLevel) -> String {
match level {
@step_common.DetailLevel::Simplified => "simplified"
@step_common.DetailLevel::Detailed => "detailed"
@step_common.DetailLevel::FullyModeled => "fully-modeled"
}
}
///|
/// The canonical CLI name of a thread representation.
pub fn thread_rep_name(rep : @step_common.ThreadRepresentation) -> String {
match rep {
@step_common.ThreadRepresentation::None => "none"
@step_common.ThreadRepresentation::Cosmetic => "cosmetic"
@step_common.ThreadRepresentation::Helical => "helical"
}
}
///|
/// The detail level implied by a thread override, if any.
///
/// A `Helical` thread request implies `FullyModeled`; the other modes keep the
/// caller's detail level.
pub fn detail_level_with_threads(
level : @step_common.DetailLevel,
threads : @step_common.ThreadRepresentation?,
) -> @step_common.DetailLevel {
match threads {
Some(@step_common.ThreadRepresentation::Helical) =>
@step_common.DetailLevel::FullyModeled
_ => level
}
}
///|
/// Replaces a chamfered prism with the equivalent extruded profile.
///
/// The STEP kernel's chamfered-prism compiler chooses face-loop direction from
/// a signed area test that can flip when the solid is translated away from the
/// origin, producing inconsistently oriented shared edges. The imported
/// hardware keeps its outline and bores but drops the small edge chamfer, so
/// every exported STEP validates under translation.
fn flatten_chamfered_prism(node : @step_cad.SceneNode) -> @step_cad.SceneNode {
match node.shape {
@step_cad.Shape::ChamferedPrism(prism) => {
let mut z0 = prism.levels[0].0
let mut z1 = prism.levels[0].0
for level in prism.levels {
if level.0 < z0 {
z0 = level.0
}
if level.0 > z1 {
z1 = level.0
}
}
let height = if z1 - z0 > 1.0e-9 { z1 - z0 } else { 1.0 }
let holes = match prism.hole {
Some(hole) => [hole]
None => []
}
let shape = @step_cad.ExtrudedProfile::new(prism.base, height, holes~)
let placed = shape
.with_name(node.name)
.with_color(node.color)
.translate(z=z0)
transform_scene_node(placed, @step_cad.Transform::from_node(node))
}
@step_cad.Shape::Union(union) => {
let children = union.nodes.map(flatten_chamfered_prism)
let rebuilt = @step_cad.union_all(children, name=node.name).with_color(
node.color,
)
transform_scene_node(rebuilt, @step_cad.Transform::from_node(node))
}
@step_cad.Shape::Difference(difference) => {
let base = flatten_chamfered_prism(difference.base)
let cutters = difference.cutters.map(flatten_chamfered_prism)
let rebuilt = @step_cad.difference(base, cutters, name=node.name).with_color(
node.color,
)
transform_scene_node(rebuilt, @step_cad.Transform::from_node(node))
}
_ => node
}
}
///|
/// Materializes one component layer with its placement applied.
fn placed_layer_node(
layer : @step_common.ComponentLayer,
) -> @step_cad.SceneNode {
let (rx, ry, rz) = layer.placement.to_euler()
layer.shape
.with_name(layer.name)
.with_color(layer.color)
.rotate_x(rx)
.rotate_y(ry)
.rotate_z(rz)
.translate(
x=layer.placement.trans.0,
y=layer.placement.trans.1,
z=layer.placement.trans.2,
)
}
///|
/// The leaf name of a layer or connector path (`"gearbox/sun"` -> `"sun"`).
fn layer_leaf_name(name : String) -> String {
match name.rev_find("/") {
Some(index) =>
String::unsafe_substring(name, start=index + 1, end=name.length())
None => name
}
}
///|
/// Builds one `BodyPart` from an already placed scene node.
fn body_part_from_placed_node(
placed : @step_cad.SceneNode,
density : @urdf.Density,
part : PartMeta?,
) -> BodyPart {
let (x0, x1, y0, y1, z0, z1) = placed.bounding_box()
let sx = if x1 - x0 > 1.0e-3 { x1 - x0 } else { 1.0 }
let sy = if y1 - y0 > 1.0e-3 { y1 - y0 } else { 1.0 }
let sz = if z1 - z0 > 1.0e-3 { z1 - z0 } else { 1.0 }
let origin = @urdf.Origin::from_mm_deg(
x=(x0 + x1) / 2.0,
y=(y0 + y1) / 2.0,
z=(z0 + z1) / 2.0,
)
let inertial = @urdf.Inertial::from_box_density(
sx / 1000.0,
sy / 1000.0,
sz / 1000.0,
density~,
origin~,
)
let collision = @urdf.Collision::new(
@urdf.Geometry::box_mm(sx, sy, sz),
name=Some(placed.name),
origin~,
)
BodyPart::custom(
placed.name,
placed,
inertial,
collisions=[collision],
density~,
part~,
)
}
///|
/// Copies a STEP component's semantic mate connectors onto a CAD component.
///
/// Names are preserved (optionally prefixed). The implicit `"origin"` mate
/// always survives, and duplicate names keep the first connector.
fn Component::add_step_connectors(
self : Component,
step_comp : @step_common.Component,
connector_prefix~ : String = "",
only_prefix~ : String? = None,
) -> Component {
let mut comp = self
for connector in step_comp.connectors() {
let keep = match only_prefix {
Some(prefix) =>
connector.name == prefix || connector.name.has_prefix(prefix + "-")
None => true
}
if !keep {
continue
}
let name = connector_prefix + connector.name
if comp.mates.contains(name) {
continue
}
comp = comp.add_mate({ ..connector, name, })
}
comp
}
///|
/// Converts one STEP primitive component into CAD bodies.
///
/// Each layer of the STEP component becomes a `BodyPart` in the local frame
/// placed by the millimeter/degree offset. The first body receives `part` so a
/// multi-layer primitive (a screw shank, head, and socket, or a bearing's
/// rings and balls) counts once in the bill of materials.
pub fn BodyPart::from_step_component(
step_comp : @step_common.Component,
density~ : @urdf.Density = @urdf.Density::steel_mild(),
part~ : PartMeta? = None,
x_mm~ : Double = 0.0,
y_mm~ : Double = 0.0,
z_mm~ : Double = 0.0,
rx_deg~ : Double = 0.0,
ry_deg~ : Double = 0.0,
rz_deg~ : Double = 0.0,
) -> Array[BodyPart] {
let xform = urdf_transform_from_mm_deg(
x_mm~,
y_mm~,
z_mm~,
rx_deg~,
ry_deg~,
rz_deg~,
)
let bodies : Array[BodyPart] = []
let mut first = true
for node in step_comp.nodes() {
let safe = flatten_chamfered_prism(node)
let placed = transform_scene_node_urdf(safe, xform)
let (x0, x1, y0, y1, z0, z1) = placed.bounding_box()
let sx = if x1 - x0 > 1.0e-3 { x1 - x0 } else { 1.0 }
let sy = if y1 - y0 > 1.0e-3 { y1 - y0 } else { 1.0 }
let sz = if z1 - z0 > 1.0e-3 { z1 - z0 } else { 1.0 }
let cx = (x0 + x1) / 2.0
let cy = (y0 + y1) / 2.0
let cz = (z0 + z1) / 2.0
let origin = @urdf.Origin::from_mm_deg(x=cx, y=cy, z=cz)
let inertial = @urdf.Inertial::from_box_density(
sx / 1000.0,
sy / 1000.0,
sz / 1000.0,
density~,
origin~,
)
let collision = @urdf.Collision::new(
@urdf.Geometry::box_mm(sx, sy, sz),
name=Some(placed.name),
origin~,
)
let body_part = if first { part } else { None }
bodies.push(
BodyPart::custom(
placed.name,
placed,
inertial,
collisions=[collision],
density~,
part=body_part,
),
)
first = false
}
bodies
}
///|
/// Imports an exact vendor STEP file as a purchased body.
///
/// The imported B-Rep is emitted verbatim (rigidly placed by the body's
/// transform) in the flat STEP output. The URDF, collision checks, and glTF
/// fallback use the imported solid's bounding box, so the body has a real
/// mass, a conservative collision primitive, and a box visual without
/// re-tessellating the vendor geometry.
pub fn BodyPart::imported_step(
name : String,
step_text : String,
source~ : String = "",
density~ : @urdf.Density = @urdf.Density::g_per_cm3(1.85),
color~ : @step_cad.Rgb = @step_cad.Rgb::grey(),
part~ : PartMeta? = None,
x_mm~ : Double = 0.0,
y_mm~ : Double = 0.0,
z_mm~ : Double = 0.0,
rx_deg~ : Double = 0.0,
ry_deg~ : Double = 0.0,
rz_deg~ : Double = 0.0,
) -> BodyPart {
let imported = match @step_cad.ImportedStep::from_string(step_text, source~) {
Ok(imported) => imported.renamed(name)
Err(info) =>
abort(
"error: could not import STEP for body '\{name}'" +
(if source == "" { "" } else { " from " + source }) +
": " +
info.message,
)
}
let shape = imported.as_shape().with_name(name).with_color(color)
let xform = urdf_transform_from_mm_deg(
x_mm~,
y_mm~,
z_mm~,
rx_deg~,
ry_deg~,
rz_deg~,
)
let placed = transform_scene_node_urdf(shape, xform)
let (x0, x1, y0, y1, z0, z1) = placed.bounding_box()
let sx = if x1 - x0 > 1.0e-3 { x1 - x0 } else { 1.0 }
let sy = if y1 - y0 > 1.0e-3 { y1 - y0 } else { 1.0 }
let sz = if z1 - z0 > 1.0e-3 { z1 - z0 } else { 1.0 }
let origin = @urdf.Origin::from_mm_deg(
x=(x0 + x1) / 2.0,
y=(y0 + y1) / 2.0,
z=(z0 + z1) / 2.0,
)
let inertial = @urdf.Inertial::from_box_density(
sx / 1000.0,
sy / 1000.0,
sz / 1000.0,
density~,
origin~,
)
let collision = @urdf.Collision::new(
@urdf.Geometry::box_mm(sx, sy, sz),
name=Some(name),
origin~,
)
BodyPart::custom(
name,
placed,
inertial,
collisions=[collision],
density~,
part~,
)
}
///|
/// Converts a STEP primitive component into a CAD `Component`.
///
/// The component inherits the primitive's description, its metadata as design
/// parameters, and its modeled-feature list.
pub fn Component::from_step_component(
name : String,
step_comp : @step_common.Component,
density~ : @urdf.Density = @urdf.Density::steel_mild(),
part~ : PartMeta? = None,
connector_prefix~ : String = "",
include_connectors~ : Bool = true,
x_mm~ : Double = 0.0,
y_mm~ : Double = 0.0,
z_mm~ : Double = 0.0,
rx_deg~ : Double = 0.0,
ry_deg~ : Double = 0.0,
rz_deg~ : Double = 0.0,
) -> Component {
let meta = step_comp.metadata()
let mut comp = Component::new(name, description=step_comp.description())
comp = comp
.with_param("designation", meta.designation)
.with_param("standard", meta.standard)
.with_param("family", meta.family)
.with_param("size", meta.size)
.with_param("features_modeled", step_comp.features().modeled.join(","))
comp = comp.add_bodies(
BodyPart::from_step_component(
step_comp,
density~,
part=None,
x_mm~,
y_mm~,
z_mm~,
rx_deg~,
ry_deg~,
rz_deg~,
),
)
if include_connectors {
comp = comp.add_step_connectors(step_comp, connector_prefix~)
}
match part {
Some(p) => comp.with_part(p)
None => comp
}
}
///|
/// The names of a multi-layer STEP component's layers, in model order.
pub fn step_component_layer_names(
step_comp : @step_common.Component,
) -> Array[String] {
step_comp.layers().map(fn(layer) { layer.name })
}
///|
/// Converts one named layer of a multi-layer STEP component into a CAD
/// `Component`.
///
/// This splits a composite primitive (the sun, planet, and ring layers of a
/// Tier-1 planetary gearbox, or the rolling elements of a bearing) into
/// independent kinematic and printable links while preserving each layer's
/// exact geometry. Semantic mate connectors whose names begin with the layer
/// name are propagated; the implicit `"origin"` mate always exists.
pub fn Component::from_step_layer(
name : String,
step_comp : @step_common.Component,
layer_name : String,
density~ : @urdf.Density = @urdf.Density::steel_mild(),
part~ : PartMeta? = None,
connector_prefix~ : String = "",
include_connectors~ : Bool = true,
apply_placement~ : Bool = true,
x_mm~ : Double = 0.0,
y_mm~ : Double = 0.0,
z_mm~ : Double = 0.0,
rx_deg~ : Double = 0.0,
ry_deg~ : Double = 0.0,
rz_deg~ : Double = 0.0,
) -> Component {
let xform = urdf_transform_from_mm_deg(
x_mm~,
y_mm~,
z_mm~,
rx_deg~,
ry_deg~,
rz_deg~,
)
let mut comp = Component::new(name, description=step_comp.description())
let mut first = true
for layer in step_comp.layers() {
if layer.name != layer_name && layer_leaf_name(layer.name) != layer_name {
continue
}
let source = if apply_placement {
placed_layer_node(layer)
} else {
layer.shape.with_name(layer.name).with_color(layer.color)
}
let placed = transform_scene_node_urdf(source, xform)
comp = comp.add_body(
body_part_from_placed_node(
placed,
density,
if first {
part
} else {
None
},
),
)
first = false
}
comp = comp
.with_param("designation", step_comp.metadata().designation)
.with_param("layer", layer_name)
if include_connectors {
comp = comp.add_step_connectors(
step_comp,
connector_prefix~,
only_prefix=Some(layer_name),
)
}
match part {
Some(p) => comp.with_part(p)
None => comp
}
}