Wave 153/509: kernel: the general fill is the iso-parametric patch on three or four edges (and 1 more)

2 commits, squashed; the originals stay reachable from tag archive/merge-main-develop.

- 3ef93b363 jyviko: kernel: the general fill is the iso-parametric patch on three or four edges
- cfb5dc3ba jyviko: solidcraft-smlib: Brep::planar_faces and Brep::boolean2d

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
jyviko
2026-10-22 00:59:46 -04:00
parent 73713b0de2
commit 894022904f
6 changed files with 298 additions and 28 deletions
+247 -25
View File
@@ -5,15 +5,18 @@
//! parameters are plane coordinates, so each edge's pcurve is its exact projection onto the
//! plane.
//!
//! The general fill (`solidcraft_geom::fill_general`), which also meets the faces beside the loop
//! with G1 or G2 and passes through given points, is not ported yet: its surface's parameters are
//! developed from the loop, so the loop's edges have no exact pcurve on it, and the frames across
//! each edge come from `bridge::frames_across`.
//! The general fill, which also meets the faces beside the loop with G1 or G2, passes through
//! given points, and fills loops that bound no height field, is a patch whose boundary rows are
//! the loop's own edges (`solidcraft_geom::fill_iso`): each edge's pcurve is a straight line in
//! (u, v). It takes loops of three or four line or spline edges; the frames across each edge are
//! read off the neighbouring face's record surface (exact second derivatives for G2).
use solidcraft_geom::Vec3;
use solidcraft_geom::brep::eval::SurfaceEval;
use solidcraft_geom::brep::{self as b, Curve2, eval::CurveEval};
use solidcraft_geom::bspline::{HPoint, SplineError};
use solidcraft_geom::fill_general::MAX_FILL_POINTS;
use solidcraft_geom::fill_general::{Across, MAX_FILL_POINTS};
use solidcraft_geom::fill_iso::{IsoEdge, IsoSpec};
use crate::body::Body;
use crate::bridge::Continuity;
@@ -110,14 +113,217 @@ pub fn patch_edges_report(body: &Body, at: &[Vec3], spec: &PatchSpec) -> Result<
return patch_edges_crowned(body, at, spec.crown).map(|b| (b, PatchReport::default()));
}
body.require_brep("patch")?;
Err(general_fill_unported())
let record = crate::native::brep_record(body)?;
let chain = picked_loop(&record, at, body.size() * 0.05 + 1e-6)?;
let mut orders = vec![spec.continuity; chain.len()];
for (p, g) in &spec.edges {
let e = nearest_edge(&record, *p, body.size() * 0.05 + 1e-6).ok_or_else(|| KernelError::Invalid(format!("no edge at {p:?}")))?;
let k = chain.iter().position(|c| c.0 == e).ok_or_else(|| KernelError::Invalid("a continuity pick is not on an edge of the loop".into()))?;
if let Some(slot) = orders.get_mut(k) {
*slot = *g;
}
}
if spec.crown != 0.0 && orders.iter().all(|g| *g == Continuity::G0) {
return Err(KernelError::Invalid("not supported yet: a crown on a patch through points with no g1 or g2 edge".into()));
}
general_fill(body, &record, &chain, &orders, &spec.points, spec.crown)
}
/// The general fill's refusal until it is ported (module docs).
fn general_fill_unported() -> KernelError {
KernelError::Invalid(
"not supported yet: a patch meeting its neighbours with g1 or g2, through points, or on a loop that bounds no height field".into(),
)
/// The general fill of the loop `chain` of the record's edges, edge `k` meeting the face beside it
/// with `orders[k]` (module docs).
fn general_fill(
body: &Body,
record: &b::Brep,
chain: &[(usize, bool)],
orders: &[Continuity],
points: &[Vec3],
crown: f64,
) -> Result<(Body, PatchReport)> {
if !(3..=4).contains(&chain.len()) {
return Err(KernelError::Invalid(format!("not supported yet: a general patch on a loop of {} edges (three or four)", chain.len())));
}
let edges: Vec<IsoEdge> = chain.iter().map(|&(e, forward)| iso_edge(record, e, forward)).collect::<Result<_>>()?;
let size = body.size().max(solidcraft_geom::LINEAR_TOL);
let mut beside: Vec<Option<Beside>> = Vec::with_capacity(chain.len());
for (&(e, forward), order) in chain.iter().zip(orders) {
beside.push(if *order == Continuity::G0 { None } else { Some(Beside::new(record, e, forward, *order == Continuity::G2, size)?) });
}
// Where a G1/G2 edge's neighbour and the one before disagree at their corner.
let n = chain.len();
let mut clash = vec![false; n];
for k in 0..n {
let prev = (k + n - 1) % n;
let (Some(Some(a)), Some(Some(b))) = (beside.get(prev), beside.get(k)) else { continue };
let (Some(ea), Some(eb)) = (edges.get(prev), edges.get(k)) else { continue };
let (end, start) = (ea.knots.last().copied().unwrap_or(0.0), eb.knots.first().copied().unwrap_or(0.0));
if let (Some(x), Some(y)) = (a.across(record, end)?, b.across(record, start)?) {
clash[k] = x.normal.dot(y.normal).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos();
}
}
let mut across = |k: usize, ts: &[f64]| -> std::result::Result<Vec<Option<Across>>, String> {
match beside.get(k) {
None => Err("no such edge".into()),
Some(None) => Ok(vec![None; ts.len()]),
Some(Some(side)) => ts.iter().map(|t| side.across(record, *t).map_err(|e| e.to_string())).collect(),
}
};
let spec = IsoSpec { tol: face_tolerance(body), angle_tol: PATCH_ANGLE_TOL_DEG.to_radians(), crown, points };
let fill = solidcraft_geom::fill_iso::iso_fill(&edges, &mut across, &clash, &spec).map_err(spline_error)?;
let surface = surface_record(&fill.surface)?;
let made = patch_body(body, record, chain, surface, true, &Pcurves::Sides(&fill.sides), face_tolerance(body))?;
let a = fill.achieved;
let report = PatchReport {
general: true,
gap: 0.0,
normal_deviation_deg: a.normal_deviation.to_degrees(),
normal_deviation_all_deg: a.normal_deviation_all.to_degrees(),
curvature_mismatch: a.curvature_mismatch,
point_gap: a.point_deviation,
};
Ok((made, report))
}
/// A loop edge as the patch takes it: a non-rational B-spline on the edge's interval, running
/// the loop's way, its ends on the edge's vertices. Conics and traced curves have no such form
/// in their own parameter (an arc's angle is no rational function of a NURBS parameter), and a
/// rational edge none the Coons sum can blend: refused by name.
fn iso_edge(record: &b::Brep, e: usize, forward: bool) -> Result<IsoEdge> {
let edge = record.edges.get(e).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?;
let v3 = |p: &[f64; 3]| Vec3::new(p[0], p[1], p[2]);
let [a, z] = edge.interval;
let (degree, knots, points): (usize, Vec<f64>, Vec<Vec3>) = match &edge.curve {
b::Curve::Line { start, end } => {
let (s, t) = (v3(start), v3(end));
(1, vec![a, a, z, z], vec![s + (t - s) * a, s + (t - s) * z])
}
b::Curve::Polyline { points } => {
let mut knots = vec![0.0];
knots.extend((0..points.len()).map(|i| i as f64));
knots.push(points.len().saturating_sub(1) as f64);
(1, knots, points.iter().map(v3).collect())
}
b::Curve::Spline { knots, points } => (knots.len().saturating_sub(points.len() + 1), knots.clone(), points.iter().map(v3).collect()),
b::Curve::RationalSpline { knots, homogeneous } if homogeneous.windows(2).all(|w| w[0][3] == w[1][3]) => (
knots.len().saturating_sub(homogeneous.len() + 1),
knots.clone(),
homogeneous.iter().map(|h| Vec3::new(h[0] / h[3], h[1] / h[3], h[2] / h[3])).collect(),
),
_ => {
return Err(KernelError::Invalid(format!(
"not supported yet: a general patch on edge {e}, a circle, ellipse, rational or traced curve (its pcurve on the patch has no exact form in its own parameter)"
)));
}
};
// The piece on the edge's interval, then run the loop's way.
let h: Vec<HPoint> = points.iter().map(|p| HPoint::weighted(*p, 1.0)).collect();
let (mut knots, h) = solidcraft_geom::bspline::segment(degree, &knots, &h, a, z).map_err(spline_error)?;
let mut points: Vec<Vec3> = h.iter().map(|p| p.xyz()).collect();
if !forward {
knots = knots.iter().rev().map(|k| a + z - k).collect();
points.reverse();
}
// Its ends exactly on the loop's vertices.
let vertex = |end: usize| record.vertices.get(edge.vertices[end] as usize).map(|v| v3(&v.point));
let (first, last) = if forward { (vertex(0), vertex(1)) } else { (vertex(1), vertex(0)) };
if let (Some(p), Some(q), Some(f)) = (first, last, points.first_mut()) {
*f = p;
if let Some(l) = points.last_mut() {
*l = q;
}
}
Ok(IsoEdge { degree, knots, points })
}
/// The face beside a G1/G2 edge, read at points of the edge: its record surface, which side of
/// it is outward, whether its boundary runs the edge the loop's way, and whether its curvature
/// is read (G2).
struct Beside {
surface: SurfaceEval,
side: f64,
along: bool,
edge: usize,
forward: bool,
curvature: bool,
reach: f64,
}
impl Beside {
fn new(record: &b::Brep, e: usize, forward: bool, curvature: bool, size: f64) -> Result<Beside> {
let edge = record.edges.get(e).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?;
let [u] = edge.uses.as_slice() else {
return Err(KernelError::Invalid("an edge of the loop lies between two faces: g1 and g2 need the one face beside it".into()));
};
let face = record.faces.get(u.face as usize).ok_or_else(|| KernelError::Failed("patch: face reference".into()))?;
let surface =
SurfaceEval::new(&face.surface).map_err(|err| KernelError::Invalid(format!("the face beside edge {e} cannot be evaluated: {err}")))?;
let outward = record
.shells
.iter()
.find_map(|s| match s {
b::Shell::Faces { faces, .. } => faces.iter().find(|f| f.face == u.face).map(|f| f.forward),
_ => None,
})
.unwrap_or(true);
let used_forward = match face.loops.get(u.r#loop as usize) {
Some(b::Loop::Edges { edges }) => edges.get(u.position as usize).map(|x| x.forward),
_ => None,
}
.ok_or_else(|| KernelError::Failed("patch: edge use".into()))?;
// A face's boundary runs counter-clockwise about its outward normal: the record's loops
// run so about the natural normal, reversed where the outward side is the other.
let runs_forward = used_forward == outward;
Ok(Beside {
surface,
side: if outward { 1.0 } else { -1.0 },
along: runs_forward == forward,
edge: e,
forward,
curvature,
reach: (size * 1e-4).max(1e-6),
})
}
/// The neighbour's conditions at parameter `t` of the loop's edge (its `IsoEdge`, run the
/// loop's way, whose parameter is the edge's reversed where the loop runs against it):
/// its normal, the direction it leaves the edge in, away from it, and for G2 its curvature
/// vector along that direction. `None` where the edge has no tangent there.
fn across(&self, record: &b::Brep, t: f64) -> Result<Option<Across>> {
let edge = record.edges.get(self.edge).ok_or_else(|| KernelError::Failed("patch: edge reference".into()))?;
let [a, z] = edge.interval;
let tau = if self.forward { t } else { a + z - t };
let curve = CurveEval::new(&edge.curve).map_err(|e| KernelError::Invalid(e.to_string()))?;
let Some((p, d)) = curve.derivs(tau) else { return Ok(None) };
let Some(tangent) = (d * if self.forward { 1.0 } else { -1.0 }).normalized() else { return Ok(None) };
let uv =
self.surface.project(p, None, self.reach).ok_or_else(|| KernelError::Invalid("a picked edge is not on the face beside it".into()))?;
let (_, su, sv) =
self.surface.derivs(uv[0], uv[1]).ok_or_else(|| KernelError::Failed("patch: the face beside an edge has no derivatives".into()))?;
let normal =
(su.cross(sv) * self.side).normalized().ok_or_else(|| KernelError::Failed("patch: the face beside an edge has no normal".into()))?;
// Away from the face: its boundary's direction × its outward normal.
let boundary = if self.along { tangent } else { tangent * -1.0 };
let leave = boundary.cross(normal).normalized().ok_or_else(|| KernelError::Invalid("the boundary runs along the face's normal".into()))?;
let bend = if self.curvature { Some(normal * normal_curvature(&self.surface, uv, normal, leave)?) } else { None };
Ok(Some(Across { leave, normal, bend }))
}
}
/// The normal curvature of a surface at `uv` along the unit tangent `w`: `n·r''` of the unit-speed
/// curve on it leaving that way (the second fundamental form, exact second derivatives).
fn normal_curvature(s: &SurfaceEval, uv: [f64; 2], n: Vec3, w: Vec3) -> Result<f64> {
let fail = || KernelError::Failed("patch: the face beside an edge has no curvature there".into());
let (_, ru, rv) = s.derivs(uv[0], uv[1]).ok_or_else(fail)?;
let (ruu, ruv, rvv) = s.second(uv[0], uv[1]).ok_or_else(fail)?;
// w = ru·α + rv·β, solved in the tangent plane.
let (e, f, g) = (ru.dot(ru), ru.dot(rv), rv.dot(rv));
let det = e * g - f * f;
if !(det > 0.0) {
return Err(fail());
}
let (wu, wv) = (w.dot(ru), w.dot(rv));
let (alpha, beta) = ((g * wu - f * wv) / det, (e * wv - f * wu) / det);
let k = n.dot(ruu * (alpha * alpha) + ruv * (2.0 * alpha * beta) + rvv * (beta * beta));
k.is_finite().then_some(k).ok_or_else(fail)
}
/// [`crate::patch_edges`] with a crown on the fitted face: positive makes the patch's middle
@@ -156,14 +362,23 @@ pub(crate) fn patch_loop(body: &Body, at: &[Vec3], crown: f64) -> Result<Body> {
let mut point = |k: usize, t: f64| sides.get_mut(k).and_then(|s| s.point(t));
let fill = match solidcraft_geom::fill::fill_loop(chain.len(), &mut point, tol, crown) {
Ok(fill) => fill,
Err(SplineError::Unsupported(_)) if crown == 0.0 => return Err(general_fill_unported()),
// Not a height field over its plane: the general fill, when no crown asks for the
// height field's bump.
Err(SplineError::Unsupported(_)) if crown == 0.0 => {
let orders = vec![Continuity::G0; chain.len()];
return general_fill(body, &record, &chain, &orders, &[], 0.0).map(|(b, _)| b);
}
Err(e) => return Err(spline_error(e)),
};
let projection = Projection { origin: fill.origin, axes: fill.axes };
(surface_record(&fill.surface)?, fill.counter_clockwise, Some(projection))
}
};
patch_body(body, &record, &chain, surface, ccw, pcurve.as_ref(), face_tolerance(body))
let pcurves = match &pcurve {
Some(p) => Pcurves::Projected(p),
None => Pcurves::Computed,
};
patch_body(body, &record, &chain, surface, ccw, &pcurves, face_tolerance(body))
}
/// The closed loop of `record`'s edges picked by points on them (the edge nearest each, within
@@ -321,6 +536,14 @@ fn conic_on(frame: &b::Frame, radii: [f64; 2], on: &dyn Fn([f64; 3]) -> bool, n:
on(frame.origin) && radii[0] * axis(frame.x_axis) + radii[1] * axis(frame.y_axis) <= tol
}
/// Where a patch's pcurves come from: the record's routine (a plane), the exact projection onto
/// a height field's plane, or the patch's own sides (each edge a straight line in (u, v)).
enum Pcurves<'a> {
Computed,
Projected(&'a Projection),
Sides(&'a [[[f64; 2]; 2]]),
}
/// The plane a height field stands on: its parameters are coordinates along `axes` from `origin`.
struct Projection {
origin: Vec3,
@@ -389,15 +612,7 @@ fn surface_record(s: &solidcraft_geom::bspline::NurbsSurface) -> Result<b::Surfa
/// counter-clockwise about the surface's natural normal (`ccw`: the chain already does), each
/// edge's pcurve the exact projection where the surface is a height field. Its history is over
/// `[body]`: the face is new, each edge the body's own.
fn patch_body(
body: &Body,
record: &b::Brep,
chain: &[(usize, bool)],
surface: b::Surface,
ccw: bool,
projection: Option<&Projection>,
tol: f64,
) -> Result<Body> {
fn patch_body(body: &Body, record: &b::Brep, chain: &[(usize, bool)], surface: b::Surface, ccw: bool, pcurves: &Pcurves, tol: f64) -> Result<Body> {
let fail = |m: &str| KernelError::Failed(format!("patch: {m}"));
let mut vertices: Vec<[f64; 3]> = Vec::new();
let mut vertex_of: std::collections::HashMap<u32, u32> = std::collections::HashMap::new();
@@ -413,13 +628,20 @@ fn patch_body(
vertices.push(record.vertices.get(v as usize).ok_or_else(|| fail("vertex reference"))?.point);
}
}
let given = match projection {
Some(p) => Some(p.pcurve(&edge.curve, edge.interval).ok_or_else(|| {
let given = match pcurves {
Pcurves::Sides(sides) => {
let [s, z] = sides.get(k).copied().ok_or_else(|| fail("side"))?;
let [a, b] = edge.interval;
// The loop's start of the edge is its interval's start when the loop runs along it.
let (at_a, at_b) = if forward { (s, z) } else { (z, s) };
Some(Curve2::Spline { knots: vec![a, a, b, b], points: vec![at_a, at_b] })
}
Pcurves::Projected(p) => Some(p.pcurve(&edge.curve, edge.interval).ok_or_else(|| {
KernelError::Invalid(
"not supported yet: a fitted patch on a circular, elliptic or traced edge (it has no exact pcurve on the fit)".into(),
)
})?),
None => None,
Pcurves::Computed => None,
};
edges.push(PartEdge { curve: edge.curve.clone(), interval: edge.interval, vertices: ends });
uses.push(PartUse { edge: k as u32, forward, given });
+1 -1
View File
@@ -1 +1 @@
1934b5799653dd205182456943bfb29beccaae92
c46946993db8e757ed6f4cc1983ab277a7891b1d
+12 -1
View File
@@ -1,4 +1,4 @@
//! The operations block of `capi/include/smlib.h` (`smlib_boolean`, `smlib_fillet`,
//! The operations block of `capi/include/smlib.h` (`smlib_boolean`, `smlib_boolean2d`, `smlib_fillet`,
//! `smlib_chamfer`, `smlib_blend`, `smlib_fillet_variable`, `smlib_chamfer_sides`, `smlib_shell`, `smlib_offset_faces`,
//! `smlib_thicken`, `smlib_draft`, `smlib_merge_faces`, `smlib_brep_solid_count`, `smlib_imprint`; the fork's `capi/src/smlib_ops.cpp`), declared by
//! hand. Part of the FFI boundary, like its parent: called only through
@@ -48,6 +48,7 @@ type PickFn = unsafe extern "C" fn(*const RawBrep, *const f64, i64, f64, f64, *m
#[cfg(feature = "native")]
unsafe extern "C" {
fn smlib_boolean(a: *const RawBrep, b: *const RawBrep, op: i32, out: *mut *mut RawBrep) -> i32;
fn smlib_boolean2d(a: *const RawBrep, b: *const RawBrep, op: i32, out: *mut *mut RawBrep) -> i32;
fn smlib_brep_solid_count(brep: *const RawBrep, out: *mut i64) -> i32;
fn smlib_imprint(body: *const RawBrep, tool: *const RawBrep, out: *mut *mut RawBrep) -> i32;
fn smlib_fillet(
@@ -148,6 +149,11 @@ pub fn boolean(a: &Handle, b: &Handle, op: i32) -> Result<Handle, i32> {
new_brep(|out| unsafe { smlib_boolean(a.raw(), b.raw(), op, out) })
}
#[cfg(feature = "native")]
pub fn boolean2d(a: &Handle, b: &Handle, op: i32) -> Result<Handle, i32> {
new_brep(|out| unsafe { smlib_boolean2d(a.raw(), b.raw(), op, out) })
}
#[cfg(feature = "native")]
pub fn imprint(body: &Handle, tool: &Handle) -> Result<Handle, i32> {
new_brep(|out| unsafe { smlib_imprint(body.raw(), tool.raw(), out) })
@@ -309,6 +315,11 @@ pub fn boolean(_: &Handle, _: &Handle, _: i32) -> Result<Handle, i32> {
Err(NOT_BUILT)
}
#[cfg(not(feature = "native"))]
pub fn boolean2d(_: &Handle, _: &Handle, _: i32) -> Result<Handle, i32> {
Err(NOT_BUILT)
}
#[cfg(not(feature = "native"))]
pub fn imprint(_: &Handle, _: &Handle) -> Result<Handle, i32> {
Err(NOT_BUILT)
+13 -1
View File
@@ -1,5 +1,5 @@
//! The sweeps block of `capi/include/smlib.h` (`smlib_extrude`, `smlib_revolve`, `smlib_sweep`,
//! `smlib_sweep_placed`, `smlib_loft`, `smlib_loft_to_point`, `smlib_screw_sweep`, `smlib_sweep_stations`; the fork's
//! `smlib_sweep_placed`, `smlib_loft`, `smlib_loft_to_point`, `smlib_screw_sweep`, `smlib_sweep_stations`, `smlib_planar_faces`; the fork's
//! `capi/src/smlib_sweeps.cpp`), declared by hand.
//! Part of the FFI boundary, like its parent: called only through [`crate::sweeps`], which builds
//! the curve lists.
@@ -54,6 +54,7 @@ impl<'a> List<'a> {
#[cfg(feature = "native")]
unsafe extern "C" {
fn smlib_planar_faces(kinds: *const i64, n_kinds: i64, reals: *const f64, n_reals: i64, out: *mut *mut RawBrep) -> i32;
fn smlib_extrude(
kinds: *const i64,
n_kinds: i64,
@@ -147,6 +148,12 @@ fn raw(l: &List) -> Result<(*const i64, i64, *const f64, i64), i32> {
Ok((l.kinds.as_ptr(), nk, l.reals.as_ptr(), nr))
}
#[cfg(feature = "native")]
pub fn planar_faces(loops: &List) -> Result<Handle, i32> {
let (k, nk, r, nr) = raw(loops)?;
new_brep(|out| unsafe { smlib_planar_faces(k, nk, r, nr, out) })
}
#[cfg(feature = "native")]
pub fn extrude(profile: &List, direction: &[f64; 3], distance: f64, draft: f64, cap: bool) -> Result<Handle, i32> {
let (k, nk, r, nr) = raw(profile)?;
@@ -206,6 +213,11 @@ pub fn sweep_stations(profile: &List, maps: &[f64], ends: i32) -> Result<Handle,
new_brep(|out| unsafe { smlib_sweep_stations(k, nk, r, nr, maps.as_ptr(), n, ends, out) })
}
#[cfg(not(feature = "native"))]
pub fn planar_faces(_: &List) -> Result<Handle, i32> {
Err(NOT_BUILT)
}
#[cfg(not(feature = "native"))]
pub fn extrude(_: &List, _: &[f64; 3], _: f64, _: f64, _: bool) -> Result<Handle, i32> {
Err(NOT_BUILT)
+17
View File
@@ -71,6 +71,23 @@ impl Brep {
}
}
/// `self` and `other`, sheets of planar faces on one plane ([`Brep::planar_faces`]), combined
/// as regions of that plane by `op`: `None` when the result is empty. The result's edges are
/// the inputs' own curves, split where they cross.
pub fn boolean2d(&self, other: &Brep, op: BooleanOp) -> Result<Option<Brep>> {
init()?;
let op = match op {
BooleanOp::Union => ffi::ops::BOOLEAN_UNION,
BooleanOp::Subtract => ffi::ops::BOOLEAN_SUBTRACT,
BooleanOp::Intersect => ffi::ops::BOOLEAN_INTERSECT,
};
match ffi::ops::boolean2d(&self.0, &other.0, op) {
Ok(h) => Ok(Some(Brep(h))),
Err(ffi::ERR_EMPTY) => Ok(None),
Err(s) => Err(error(s)),
}
}
/// `self` with each face `tool` meets cut along the intersection, the pieces kept as faces of
/// one body: `None` when the tool meets no face. Tagged operands give the pieces' history
/// (each piece is a split of the face it was cut from).
+8
View File
@@ -130,6 +130,14 @@ impl List {
}
impl Brep {
/// A sheet of planar faces bounded by `loops`: closed loops of curves in one plane, in any
/// order, nested as outer loops, their holes and islands in the holes.
pub fn planar_faces(loops: &[Curve]) -> Result<Brep> {
init()?;
let l = List::of(loops)?;
ffi::sweeps::planar_faces(&l.raw()).map(Brep).map_err(error)
}
/// The planar `profile` extruded `distance` along the unit `direction` (square to its plane).
/// `draft` (radians) leans the walls: positive inward, negative outward; a drafted profile is
/// one closed loop, its curves in order, and `direction` is its normal (either way round).