masi/solvecraft
1
0
Fork 0
mirror of https://github.com/bherbruck/solidcraft.git synced 2026-11-08 13:01:52 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity
Files
00a19b33be240926fcd10281fe761bb6ee433def
solvecraft/harness/cpp/shim/offset_offset_executive_p1.cpp
T
Brett Lawson 86e36540dd difftest: ReplaceImplicitOffsets on extrusion, plane and B-spline offset bases (#1476) 
Shim mode 7 builds one CreateFaceFromSurface face on an owning
SmOffsetSurface of a real SmSurfOfExtrusion (lazy, no NURB), SmPlane or
SmBSplineSurface, runs ReplaceImplicitOffsets and records the status, the
result surface type, domains and sampled points. 12 fixtures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MNXLXj2sJf943y2dDF36Vy
2026-10-29 10:42:45 +01:00

1217 lines
56 KiB
C++
Raw Blame History

// SPDX-License-Identifier: Apache-2.0
// Native adapter for offset.offset_executive_p1 (PR #175).
// Upstream: source/SMLib/inc/SmOffsetExecutive.h, src/SmOffsetExecutive.cpp.
//
// Rust API/protocol: crates/solidcore-ffi/src/units/offset_offset_executive_p1.rs.
// config -> default/custom geometry ctor views, native executive ctor/dtor,
// state setters/getters, SmRelation/GetOffsetEdgeuse.
// Config input begins distance, approx_tol, tangency_tol_radians, operation.
// Its constructor-state and final-state snapshots both use the supplied geometry;
// other modes retain the native default 2-degree tangency constructor behavior.
// synchronize -> SyncronizeOffsetEdgeuses, which calls all four owned static helpers.
// extend -> GetCreateExtendedSurface with real SmPlane/SmBSplineSurface geometry.
// Extension takes an internal nonnegative magnitude, not a public signed offset:
// SmOffsetExecutive.cpp:114-120,206-223 pass fabs(distance) to the geometry creator
// and preserve the sign via SetInset; SmBrep.cpp:12004 uses bounding-sphere radius/2.
// Reject negative extension distances before geometry construction as SC_ERR_ARG;
// both signed zeros remain valid. Config only observes state, so stays sign-agnostic.
// probe -> independent safe topology paths; not a replacement for arithmetic tests.
// face tail -> BuildOffsetOfFaceuse's contained-domain branch on a MakeFaceWithCurves
// plane face, including MapEdgeuses and self-intersection merging.
// map twin -> MapEdgeuses alone, between two MakeFaceWithCurves rectangle faces.
// replace -> ReplaceImplicitOffsets on one CreateFaceFromSurface face whose surface is
// an owning SmOffsetSurface(d, base) of a real SmPlane, SmBSplineSurface or
// SmSurfOfExtrusion (lazy: no NURB until GetOrCreateGwNurbPointer).
// Deviations: bounded plain-C fixture protocol, traversal IDs instead of pointers;
// extension-only nonnegative-distance validation. Native array ordering is unchanged.
// No implementation file is included; no native numerical/helper code is copied.
#include "sc_shim.h"
#include "StdAfx.h"
#include <SmAxis2Placement.h>
#include <SmBSplineCurve.h>
#include <SmBSplineSurface.h>
#include <SmBrep.h>
#include <SmContext.h>
#include <SmEdge.h>
#include <SmEdgeuse.h>
#include <SmFace.h>
#include <SmFaceuse.h>
#include <SmLine.h>
#include <SmLoop.h>
#include <SmNurbsCrv.h>
#include <SmNurbsSrf.h>
#include <SmOffsetExecutive.h>
#include <SmOffsetGeometryCreation.h>
#include <SmOffsetSurface.h>
#include <SmPlane.h>
#include <SmRegion.h>
#include <SmShell.h>
#include <SmSurfOfExtrusion.h>
#include <SmSSIData.h>
#include <SmVertex.h>
#include <SmVertexuse.h>
#include <nurbs.h>
#include <algorithm>
#include <cmath>
#include <memory>
#include <new>
#include <vector>
namespace {
constexpr int64_t max_values = 1048576;
constexpr int64_t max_items = 4096;
constexpr int64_t max_points = 65536;
constexpr int64_t max_degree = 17; // NL_MAXDEG, not an arbitrary evaluation degree.
struct Argument {};
struct Rejected { SmStatus status; };
// A second bounds check here makes malformed direct ABI calls fail as arguments,
// not read beyond the caller's buffer. Geometric invariants are checked in Rust.
struct Reader {
const double* data;
int64_t size;
int64_t pos = 0;
double number() {
if (pos >= size) throw Argument{};
double v = data[pos++];
if (!std::isfinite(v)) throw Argument{};
return v;
}
int64_t index(int64_t limit = max_items) {
double v = number();
if (v < 0 || v > (double)limit || std::floor(v) != v) throw Argument{};
return (int64_t)v;
}
bool flag() { return index(1) != 0; }
SmPoint3d point() {
double x = number(), y = number(), z = number();
return SmPoint3d(x, y, z);
}
SmPoint2d uv() {
double x = number(), y = number();
return SmPoint2d(x, y);
}
SmExtent1d interval() {
double a = number(), b = number();
if (a > b || !std::isfinite(b-a)) throw Argument{};
return SmExtent1d(a, b);
}
SmExtent2d domain() {
SmPoint2d a = uv(), b = uv();
if (!(a.x < b.x && a.y < b.y)) throw Argument{};
return SmExtent2d(a, b);
}
void done() const { if (pos != size) throw Argument{}; }
};
void constructed(SmStatus status) {
if (status != SM_SUCCESS) throw Rejected{status};
}
void put_point(std::vector<double>& out, const SmPoint3d& p) {
out.insert(out.end(), {p.x, p.y, p.z});
}
void put_domain(std::vector<double>& out, const SmExtent2d& d) {
out.insert(out.end(), {d.GetMin().x, d.GetMin().y, d.GetMax().x, d.GetMax().y});
}
template<class T> double id(const SmTArray<T*>& list, const T* p) {
if (!p) return -1;
for (ULONG i=0; i<list.GetSize(); ++i) if (list[i] == p) return (double)i;
return -2;
}
void put_ids(std::vector<double>& out, const SmTArray<SmEdgeuse*>& values,
const SmTArray<SmEdgeuse*>& traversal) {
out.push_back(values.GetSize());
for (ULONG i=0; i<values.GetSize(); ++i) out.push_back(id(traversal, values[i]));
}
std::unique_ptr<SmBrep> brep(SmContext& ctx) {
return std::unique_ptr<SmBrep>(new (ctx) SmBrep(SM_USE_DEFAULT, SM_USE_DEFAULT, &ctx));
}
// Config-only geometry-subclass fixture. Preserve base initialization and the
// inherited GetTangencyTolDegrees calculation; only the protected scalar changes.
class ConfigGeometry : public SmOffsetGeometryCreation {
public:
ConfigGeometry(double distance, double tol, double tangency_tol_radians)
: SmOffsetGeometryCreation(distance, tol) {
m_dTangencyTolRadians = tangency_tol_radians;
}
};
// Only fixture injection/observation: all behavior under test remains native.
class Executive : public SmOffsetExecutive {
public:
Executive(SmContext& ctx, SmOffsetOperationType op, SmOffsetGeometryCreation& geometry,
SmBrep* original) : SmOffsetExecutive(ctx, op, geometry, original) {}
void install(std::unique_ptr<SmBrep> offset) { m_pOffsetBrep = offset.release(); }
SmStatus relate(SmEdgeuse* a, SmEdgeuse* b) { return m_vEUToEU.RelatePair(a, b); }
void seconds(SmEdgeuse* a, SmTArray<SmEdgeuse*>& b) { m_vEUToEU.GetSeconds(a, b); }
SmStatus relate_face(SmFaceuse* a, SmFace* b) { return m_vFUToF.RelatePair(a, b); }
bool merge() const { return m_bMergeResults != FALSE; }
bool solid() const { return m_bCreateOffsetSolid != FALSE; }
SmSurface* cached(SmSurface* base) { return m_vSurfExtSurf.At(base); }
void forget(SmSurface* base) { m_vSurfExtSurf.Remove(base); }
void clear() { m_vSurfExtSurf.RemoveAll(); }
ULONG cache_count() const { return m_vSurfExtSurf.Count(); }
void faces_of(SmFaceuse* use, SmTArray<SmFace*>& faces) { m_vFUToF.GetSeconds(use, faces); }
};
std::unique_ptr<SmCurve> read_curve(Reader& rd, SmContext& ctx) {
int64_t kind = rd.index(1);
if (kind == 0) {
SmPoint3d start = rd.point(), end = rd.point();
SmExtent1d domain = rd.interval();
SmLine* line = nullptr;
SmStatus status = SmLine::CreateLineSegment(ctx, 3, start, end, line, &domain);
std::unique_ptr<SmCurve> result(line);
constructed(status);
if (!result) throw std::bad_alloc();
return result;
}
auto degree = (gw_DEGREE)rd.index(max_degree);
auto npoints = (gw_INDEX)rd.index(max_points);
if (degree < 1 || npoints <= degree) throw Argument{};
gw_INDEX n = npoints - 1, m = npoints + degree;
std::unique_ptr<gw_CURVE, decltype(&sm_FreeNurbCurve)> raw(
sm_AllocateNurbCurve(n, degree, m), &sm_FreeNurbCurve);
gw_CURVE* curve = raw.get();
if (!curve) throw std::bad_alloc();
// The native constructor tunes knots, so initialize storage BEFORE invoking it.
for (gw_INDEX i=0; i<npoints; ++i) {
curve->pol->Pw[i].x = rd.number(); curve->pol->Pw[i].y = rd.number();
curve->pol->Pw[i].z = rd.number(); curve->pol->Pw[i].w = rd.number();
}
for (gw_INDEX i=0; i<=m; ++i) curve->knt->U[i] = rd.number();
std::unique_ptr<SmCurve> result(new (ctx) SmBSplineCurve(curve, 3, FALSE, &ctx));
raw.release();
return result;
}
SmEdge* make_wire(SmContext& ctx, SmBrep* target, std::unique_ptr<SmCurve> curve,
const SmExtent1d& interval) {
SmPoint3d a(0,0,0), b(0,0,0);
constructed(curve->EvaluatePoint(interval.GetMin(), a));
constructed(curve->EvaluatePoint(interval.GetMax(), b));
SmShell* shell = nullptr;
SmVertex *v1 = nullptr, *v2 = nullptr;
constructed(target->MakeShellVertex(nullptr, a, shell, v1));
constructed(target->MakeShellVertex(nullptr, b, shell, v2));
SmEdge* edge = nullptr;
// MakeWireEdge can fail after assigning the curve to a newly made edge.
// The guard must not delete a curve already owned by that topology.
struct Pending {
SmCurve* p;
~Pending() { if (p && !p->GetOwner()) delete p; }
} pending{curve.release()};
constructed(target->MakeWireEdge(nullptr, v1, v2, pending.p, interval, SM_OT_SAME, edge));
if (!edge || !edge->GetPrimaryEdgeuse()) throw Argument{};
(void)ctx;
return edge;
}
SmEdge* unit_wire(SmContext& ctx, SmBrep* target, double y) {
SmLine* curve = nullptr;
SmExtent1d interval(0,1);
constructed(SmLine::CreateLineSegment(ctx, 3, SmPoint3d(0,y,0), SmPoint3d(1,y,0),
curve, &interval));
return make_wire(ctx, target, std::unique_ptr<SmCurve>(curve), interval);
}
SmFace* plane_face(SmContext& ctx, SmBrep* target, double z) {
SmExtent2d domain(SmPoint2d(0,0), SmPoint2d(1,1));
SmPlane* plane = new (ctx) SmPlane(SmPoint3d(0,0,z), SmVector3d(1,0,0),
SmVector3d(0,1,0), SmVector2d(1,1), domain, &ctx);
struct Pending {
SmSurface* p;
~Pending() { if (p && !p->GetOwner()) delete p; }
} pending{plane};
SmFace* face = nullptr;
constructed(target->CreateFaceFromSurface(plane, domain, face));
if (!face) throw Argument{};
return face;
}
std::unique_ptr<SmSurface> read_surface(Reader& rd, SmContext& ctx) {
int64_t kind = rd.index(1);
if (kind == 0) {
SmPoint3d origin = rd.point();
SmVector3d x = rd.point(), y = rd.point();
SmVector2d scale = rd.uv();
SmExtent2d domain = rd.domain();
return std::unique_ptr<SmSurface>(new (ctx) SmPlane(origin, x, y, scale, domain, &ctx));
}
auto p = (gw_DEGREE)rd.index(max_degree), q = (gw_DEGREE)rd.index(max_degree);
auto nu = (gw_INDEX)rd.index(max_points), nv = (gw_INDEX)rd.index(max_points);
if (p < 1 || q < 1 || nu <= p || nv <= q || (int64_t)nu*nv > max_points)
throw Argument{};
gw_INDEX r = nu+p, s = nv+q;
auto free_surface = [](gw_SURFACE* p) { smos_Free(p); };
std::unique_ptr<gw_SURFACE, decltype(free_surface)> raw(
sm_AllocateNurbSurface(nu-1, nv-1, p, q, r, s), free_surface);
gw_SURFACE* surface = raw.get();
if (!surface) throw std::bad_alloc();
for (gw_INDEX i=0; i<nu; ++i) for (gw_INDEX j=0; j<nv; ++j) {
surface->net->Pw[i][j].x = rd.number(); surface->net->Pw[i][j].y = rd.number();
surface->net->Pw[i][j].z = rd.number(); surface->net->Pw[i][j].w = rd.number();
}
for (gw_INDEX i=0; i<=r; ++i) surface->knu->U[i] = rd.number();
for (gw_INDEX i=0; i<=s; ++i) surface->knv->U[i] = rd.number();
std::unique_ptr<SmBSplineSurface> result(new (ctx) SmBSplineSurface(surface, FALSE, &ctx));
raw.release();
result->SetBSplineSurfaceForm(SM_SF_UNSPECIFIED);
return std::unique_ptr<SmSurface>(result.release());
}
void state(std::vector<double>& out, Executive& executive, SmOffsetGeometryCreation& geometry) {
SmTArray<SmFace*> faces;
executive.GetShellFaces(faces);
out.insert(out.end(), {
geometry.GetOffsetDistance(), geometry.GetThisApproxTol3d(),
(double)executive.GetOffsetOperation(), (double)executive.GetInset(),
(double)executive.GetExtendConvexEdges(), (double)executive.merge(),
(double)executive.solid(), executive.GetTangencyTolDegrees(),
executive.GetOffsetBrep() ? 1.0 : 0.0, (double)faces.GetSize()
});
}
void config(Reader& rd, std::vector<double>& out) {
double distance = rd.number(), tol = rd.number(), tangency_tol_radians = rd.number();
auto operation = (SmOffsetOperationType)rd.index(4);
bool inset = rd.flag(), extend = rd.flag(), merge = rd.flag(), solid = rd.flag();
bool install = rd.flag();
int64_t norig = rd.index(), noffset = rd.index(), nfaces = rd.index();
SmContext ctx;
auto original = brep(ctx), offset = brep(ctx), face_owner = brep(ctx);
for (int64_t i=0; i<norig; ++i) unit_wire(ctx, original.get(), (double)i);
for (int64_t i=0; i<noffset; ++i) unit_wire(ctx, offset.get(), (double)i);
for (int64_t i=0; i<nfaces; ++i) plane_face(ctx, face_owner.get(), (double)i);
SmTArray<SmEdgeuse*> originals, offsets;
SmTArray<SmFace*> faces;
original->GetEdgeuses(originals); offset->GetEdgeuses(offsets); face_owner->GetFaces(faces);
ConfigGeometry geometry(distance, tol, tangency_tol_radians);
Executive executive(ctx, operation, geometry, original.get());
out.push_back(0);
state(out, executive, geometry);
executive.SetInset(inset ? TRUE : FALSE);
executive.SetExtendConvexEdges(extend ? TRUE : FALSE);
executive.SetMergeResults(merge ? TRUE : FALSE);
executive.SetCreateOffsetSolid(solid ? TRUE : FALSE);
if (install) executive.install(std::move(offset)); // only executive deletes this B-rep.
std::vector<double> shell_records;
int64_t nsets = rd.index();
shell_records.push_back((double)nsets);
for (int64_t i=0; i<nsets; ++i) {
SmTArray<SmFace*> selectors, result;
int64_t n = rd.index();
for (int64_t j=0; j<n; ++j) {
int64_t index = rd.index();
if (index >= faces.GetSize()) throw Argument{};
selectors.Add(faces[(ULONG)index]);
}
executive.SetShellFaces(selectors);
// Mutating the caller's array checks SetShellFaces' copy, and prefilling
// the destination checks that GetShellFaces resets, rather than appends.
selectors.ReSet();
if (faces.GetSize()) result.Add(faces[0]);
executive.GetShellFaces(result);
shell_records.push_back(result.GetSize());
for (ULONG j=0; j<result.GetSize(); ++j) shell_records.push_back(id(faces, result[j]));
}
state(out, executive, geometry);
out.insert(out.end(), shell_records.begin(), shell_records.end());
int64_t npairs = rd.index();
std::vector<double> statuses;
for (int64_t i=0; i<npairs; ++i) {
int64_t a = rd.index(max_items*2), b = rd.index(max_items*2);
if (a >= originals.GetSize() || b >= offsets.GetSize()) throw Argument{};
statuses.push_back(executive.relate(originals[(ULONG)a], offsets[(ULONG)b]));
}
rd.done();
out.push_back(originals.GetSize());
for (ULONG i=0; i<originals.GetSize(); ++i) {
SmTArray<SmEdgeuse*> seconds;
out.push_back(id(offsets, executive.GetOffsetEdgeuse(originals[i])));
executive.seconds(originals[i], seconds);
put_ids(out, seconds, offsets);
}
out.push_back((double)statuses.size());
out.insert(out.end(), statuses.begin(), statuses.end());
}
// A closing segment requires distinct endpoints (SmBSplineCurve.cpp's SAME_PNT_ER).
// For exactly coincident endpoints, use a nonzero closed cubic instead; only this
// unmeasured support changes kind. Its fixed unit weights and clamped [0,1] knots
// are valid native constructor data, not a replacement for any measured geometry.
std::unique_ptr<SmCurve> closing_curve(SmContext& ctx, const SmPoint3d& start,
const SmPoint3d& end) {
if (start.x == end.x && start.y == end.y && start.z == end.z) {
std::unique_ptr<gw_CURVE, decltype(&sm_FreeNurbCurve)> raw(
sm_AllocateNurbCurve(3, 3, 7), &sm_FreeNurbCurve);
if (!raw) throw std::bad_alloc();
const SmPoint3d points[] = {start, SmPoint3d(1,0,0), SmPoint3d(0,1,0), end};
for (gw_INDEX i=0; i<4; ++i) {
raw->pol->Pw[i].x = points[i].x; raw->pol->Pw[i].y = points[i].y;
raw->pol->Pw[i].z = points[i].z; raw->pol->Pw[i].w = 1;
}
for (gw_INDEX i=0; i<8; ++i) raw->knt->U[i] = i < 4 ? 0 : 1;
std::unique_ptr<SmCurve> result(new (ctx) SmBSplineCurve(raw.get(), 3, FALSE, &ctx));
raw.release();
return result;
}
SmBSplineCurve* closing = nullptr;
SmStatus status = SmBSplineCurve::CreateLineSegment(ctx, 3, start, end, closing);
std::unique_ptr<SmCurve> result(closing);
constructed(status);
if (!result) throw std::bad_alloc();
return result;
}
// Give each mapped wire a genuine two-edge loop. The second edge closes the
// loop and is fixture scaffolding only. No UV trims are requested: synchronization
// concerns the 3D edge ranges and must also accept nonplanar B-spline curves.
SmEdge* loop_fixture(SmContext& ctx, SmBrep* target, std::unique_ptr<SmCurve> curve,
const SmExtent1d& interval, std::vector<SmEdge*>& supports) {
SmEdge* edge = make_wire(ctx, target, std::move(curve), interval);
SmVertex* a = edge->GetStartVertex();
SmVertex* b = edge->GetOtherVertex(a);
auto closing_owner = closing_curve(ctx, b->GetPoint(), a->GetPoint());
SmExtent1d unit = closing_owner->GetNaturalInterval();
struct PendingCurve {
SmCurve* p;
~PendingCurve() { if (p && !p->GetOwner()) delete p; }
} pending_curve{closing_owner.release()};
SmEdge* support = nullptr;
constructed(target->MakeWireEdge(nullptr, b, a, pending_curve.p,
unit, SM_OT_SAME, support));
if (!support) throw Argument{};
supports.push_back(support);
SmTArray<ULONG> loop_sizes;
SmTArray<SmEdgeuse*> uses;
SmTArray<SmVertex*> vertices;
loop_sizes.Add(2);
uses.Add(edge->GetPrimaryEdgeuse()); uses.Add(support->GetPrimaryEdgeuse());
SmExtent2d domain(SmPoint2d(0,0), SmPoint2d(1,1));
struct PendingSurface {
SmSurface* p;
~PendingSurface() { if (p && !p->GetOwner()) delete p; }
} plane{new (ctx) SmPlane(SmPoint3d(0,0,0), SmVector3d(1,0,0), SmVector3d(0,1,0),
SmVector2d(1,1), domain, &ctx)};
SmRegion* region = nullptr;
SmShell* shell = nullptr;
SmFace* face = nullptr;
constructed(target->MakeFaceTopology(nullptr, plane.p, SM_OT_SAME, loop_sizes, uses, vertices,
region, shell, face, FALSE, FALSE));
SmEdgeuse* use = edge->GetPrimaryEdgeuse();
if (!use || !use->GetCCWEdgeuse() || !use->GetCWEdgeuse()) throw Argument{};
return edge;
}
// Native traversal restricted to the measured edges: auxiliary closing edges are
// not part of the unit's inputs or output topology. Split descendants remain here.
void measured_traversal(SmBrep* target, const std::vector<SmEdge*>& supports,
SmTArray<SmEdge*>& edges, SmTArray<SmEdgeuse*>& uses) {
edges.ReSet(); uses.ReSet();
SmTArray<SmEdge*> all;
target->GetEdges(all);
for (ULONG i=0; i<all.GetSize(); ++i) {
if (std::find(supports.begin(), supports.end(), all[i]) != supports.end()) continue;
edges.Add(all[i]);
SmTArray<SmEdgeuse*> pair;
all[i]->GetEdgeuses(pair);
uses.Append(pair);
}
}
void put_eu_records(std::vector<double>& out, const SmTArray<SmEdge*>& edges,
const SmTArray<SmEdgeuse*>& uses) {
out.push_back(uses.GetSize());
for (ULONG i=0; i<uses.GetSize(); ++i) {
SmEdge* edge = uses[i]->GetEdge();
const SmExtent1d& interval = edge->GetInterval();
SmCurve* curve = edge->GetCurve();
out.insert(out.end(), {(double)i, id(edges, edge), interval.GetMin(), interval.GetMax(),
curve->ApproximateLength(interval, 10)});
SmPoint3d point(0,0,0);
out.push_back(curve->EvaluatePoint(interval.GetMin(), point));
put_point(out, point);
point.Set(0,0,0);
out.push_back(curve->EvaluatePoint(interval.GetMax(), point));
put_point(out, point);
}
}
void synchronize(Reader& rd, std::vector<double>& out) {
bool null_original = rd.flag(), null_other = rd.flag();
SmContext ctx;
auto original = brep(ctx), offset = brep(ctx);
SmEdgeuse* a = unit_wire(ctx, original.get(), 0)->GetPrimaryEdgeuse();
SmEdgeuse* b = unit_wire(ctx, original.get(), 1)->GetPrimaryEdgeuse();
SmTArray<SmEdgeuse*> first, second;
std::vector<SmEdge*> supports;
for (int side=0; side<2; ++side) {
int64_t n = rd.index();
for (int64_t i=0; i<n; ++i) {
auto curve = read_curve(rd, ctx);
SmExtent1d interval = rd.interval();
SmEdge* edge = loop_fixture(ctx, offset.get(), std::move(curve), interval, supports);
(side == 0 ? first : second).Add(edge->GetPrimaryEdgeuse());
}
}
rd.done();
SmOffsetGeometryCreation geometry(1, 1e-6);
Executive executive(ctx, SM_OO_SOLID_OFFSET, geometry, original.get());
SmBrep* target = offset.get();
executive.install(std::move(offset));
for (ULONG i=0; i<first.GetSize(); ++i) {
SmStatus status = executive.relate(a, first[i]);
if (status != SM_SUCCESS) throw Argument{};
}
if (!null_other) for (ULONG i=0; i<second.GetSize(); ++i) {
SmStatus status = executive.relate(b, second[i]);
if (status != SM_SUCCESS) throw Argument{};
}
if (null_original) a = nullptr;
if (null_other) b = nullptr;
SmTArray<SmEdgeuse*> before, related_a, related_b;
SmTArray<SmEdge*> measured_edges;
measured_traversal(target, supports, measured_edges, before);
double lookup_a = id(before, executive.GetOffsetEdgeuse(a));
double lookup_b = id(before, executive.GetOffsetEdgeuse(b));
executive.seconds(a, related_a); executive.seconds(b, related_b);
std::vector<double> relation_records;
put_ids(relation_records, related_a, before); put_ids(relation_records, related_b, before);
SmTArray<SmEdgeuse*> matched_a, matched_b, gap_a, gap_b;
SmStatus status = executive.SyncronizeOffsetEdgeuses(a, b, matched_a, matched_b, gap_a, gap_b);
out.insert(out.end(), {0, (double)status, lookup_a, lookup_b});
SmTArray<SmEdgeuse*> after, fixtures;
measured_traversal(target, supports, measured_edges, after);
fixtures.Append(first); fixtures.Append(second);
put_ids(out, fixtures, after);
out.insert(out.end(), relation_records.begin(), relation_records.end());
put_eu_records(out, measured_edges, after);
put_ids(out, matched_a, after); put_ids(out, matched_b, after);
put_ids(out, gap_a, after); put_ids(out, gap_b, after);
}
// NL_CrvAdv.cpp's G1 extension retries a zero end tangent using Pw[2] or
// Pw[n-2], even for a two-point curve. Check the native isocurves sampled by
// NL_SrfAdv.cpp first: otherwise an accepted degenerate bilinear fixture can
// read outside its control polygon. This is a safety check, not an extension
// implementation, and does not reject short but normalizable tangents.
void guard_two_point_isocurves(SmSurface* base) {
SmBSplineSurface* spline = SM_CAST_PTR(SmBSplineSurface, base);
if (!spline) return;
gw_SURFACE* surface = spline->GetOrCreateGwNurbPointer();
if (!surface) throw Argument{};
for (int direction=0; direction<2; ++direction) {
if ((direction == 0 ? surface->net->n : surface->net->m) != 1) continue;
gw_KNOTVECTOR* cross_knots = direction == 0 ? surface->knv : surface->knu;
for (double fraction : {0.07, 0.19, 0.45, 0.73, 0.92}) {
double parameter = (1.0-fraction)*cross_knots->U[0]
+ fraction*cross_knots->U[cross_knots->m];
std::unique_ptr<gw_CURVE, decltype(&sm_FreeNurbCurve)> curve(
sm_AllocateNurbCurve(1, 1, 3), &sm_FreeNurbCurve);
if (!curve) throw std::bad_alloc();
if (N_SrfExtractIsoCrv(surface, parameter, direction == 0 ? NL_UDIR : NL_VDIR,
curve.get(), nullptr) != 0) continue;
NL_POINT a, b;
NL_VECTOR tangent, unit;
NL_REAL magnitude = 0;
N_CPtToPtEuclid(curve->pol->Pw[0], &a);
N_CPtToPtEuclid(curve->pol->Pw[1], &b);
N_VectorDir(a, b, &tangent);
if (N_VectorNormalize(tangent, &unit, &magnitude) != 0) throw Argument{};
}
}
}
void extend(Reader& rd, std::vector<double>& out) {
double distance = rd.number(), tol = rd.number();
if (distance < 0.0) throw Argument{};
SmContext ctx;
std::vector<std::unique_ptr<SmSurface>> bases, extended;
int64_t n = rd.index();
for (int64_t i=0; i<n; ++i) bases.push_back(read_surface(rd, ctx));
std::vector<SmPoint2d> samples;
int64_t nsamples = rd.index();
for (int64_t i=0; i<nsamples; ++i) samples.push_back(rd.uv());
auto original = brep(ctx);
SmOffsetGeometryCreation geometry(distance, tol);
Executive executive(ctx, SM_OO_SOLID_OFFSET, geometry, original.get());
int64_t nactions = rd.index();
out.insert(out.end(), {0, (double)nactions});
for (int64_t i=0; i<nactions; ++i) {
int64_t action = rd.index(2);
if (action == 2) {
out.insert(out.end(), {2, (double)executive.cache_count(), 0});
executive.clear();
continue;
}
double raw_key = rd.number();
if (raw_key < -1 || std::floor(raw_key) != raw_key || raw_key >= (double)bases.size()
|| (action == 1 && raw_key < 0)) throw Argument{};
SmSurface* base = raw_key == -1 ? nullptr : bases.at((size_t)raw_key).get();
bool hit = executive.cached(base) != nullptr;
if (action == 1) {
executive.forget(base);
out.insert(out.end(), {1, hit ? 1.0 : 0.0, (double)executive.cache_count()});
continue;
}
if (base && !hit) guard_two_point_isocurves(base);
SmExtent2d domain;
SmSurface* result = nullptr;
SmStatus status = executive.GetCreateExtendedSurface(base, domain, result);
// SmOffsetExecutive deletes its map, NOT the extended surfaces. Keep each
// distinct returned allocation alive through eviction/clear and clean it
// after the executive has destroyed the map. Never wrap a base alias twice.
double result_id = -1;
if (result) {
for (size_t j=0; j<extended.size(); ++j)
if (extended[j].get() == result) result_id = (double)j;
if (result_id == -1) {
if (std::any_of(bases.begin(), bases.end(),
[result](const std::unique_ptr<SmSurface>& p){ return p.get() == result; }))
throw Argument{}; // unsupported ownership contract, not a fixture rejection.
result_id = (double)extended.size();
extended.emplace_back(result);
}
}
out.insert(out.end(), {0, (double)status, hit ? 1.0 : 0.0, result_id, result ? 1.0 : 0.0});
if (status != SM_SUCCESS) continue;
if (!result) throw Argument{};
out.push_back(result->IsKindOf(SmPlane_TYPE) ? 1 :
result->IsKindOf(SmBSplineSurface_TYPE) ? 2 : 3);
put_domain(out, domain);
out.push_back((double)samples.size());
for (const SmPoint2d& fraction : samples) {
SmPoint2d uv((1.0-fraction.x)*domain.GetMin().x + fraction.x*domain.GetMax().x,
(1.0-fraction.y)*domain.GetMin().y + fraction.y*domain.GetMax().y);
SmPoint3d point(0,0,0);
SmVector3d normal(0,0,0);
out.push_back(result->EvaluatePoint(uv, point)); put_point(out, point);
out.push_back(result->EvaluateNormal(uv, TRUE, TRUE, normal)); put_point(out, normal);
}
}
rd.done();
}
// All new geometry remains locally owned even if construction/evaluation throws.
// This guard is created before BuildOffsetOfVertex so partial native outputs are
// cleaned on operation failure as well as on snapshot-allocation exceptions.
struct VertexResult {
SmTArray<SmCurve*> curves;
SmTArray<SmOrientType> orientations;
SmSurface* surface = nullptr;
~VertexResult() {
for (ULONG i=0; i<curves.GetSize(); ++i) delete curves[i];
delete surface;
}
};
SmFace* face_on_edges(SmBrep* target, std::unique_ptr<SmSurface> surface,
const SmTArray<SmEdgeuse*>& uses) {
struct Pending {
SmSurface* p;
~Pending() { if (p && !p->GetOwner()) delete p; }
} pending{surface.release()};
SmTArray<ULONG> loops;
loops.Add(uses.GetSize());
SmTArray<SmVertex*> vertices;
SmRegion* region = nullptr;
SmShell* shell = nullptr;
SmFace* face = nullptr;
constructed(target->MakeFace(nullptr, loops, uses, vertices, pending.p,
pending.p->GetNaturalUVDomain(), SM_OT_SAME,
region, shell, face, FALSE, FALSE));
if (!face) throw Argument{};
return face;
}
// A bounded plane, an interior vertex-loop, and a genuine new edge joining it
// to the outer boundary. The interior endpoint has exactly one incident edge
// and IsStrut is true. No source/result cap is preseeded.
SmVertex* source_strut(SmContext& ctx, SmBrep* target, const SmPoint3d& point,
SmFaceuse*& source_use) {
SmExtent2d domain(SmPoint2d(-2,-2), SmPoint2d(2,2));
struct Pending {
SmSurface* p;
~Pending() { if (p && !p->GetOwner()) delete p; }
} pending{new (ctx) SmPlane(point, SmVector3d(1,0,0), SmVector3d(0,1,0),
SmVector2d(1,1), domain, &ctx)};
SmFace* face = nullptr;
constructed(target->CreateFaceFromSurface(pending.p, domain, face));
if (!face) throw Argument{};
SmTArray<SmVertex*> boundary;
face->GetVertices(boundary);
if (!boundary.GetSize()) throw Argument{};
SmVertex* start = boundary[0];
if (!start) throw Argument{};
SmVertex* vertex = nullptr;
SmLoop* loop = nullptr;
target->m_bEditingEnabled = TRUE;
constructed(target->MakeVertexLoop(face, point, loop, vertex));
if (!vertex) throw Argument{};
SmBSplineCurve* curve = nullptr;
SmStatus curve_status = SmBSplineCurve::CreateLineSegment(ctx, 3, start->GetPoint(), point, curve);
struct PendingCurve {
SmCurve* p;
~PendingCurve() { if (p && !p->GetOwner()) delete p; }
} pending_curve{curve};
constructed(curve_status);
if (!curve) throw Argument{};
SmEdge* edge = nullptr;
SmFace* split_face = nullptr;
constructed(target->MakeEdgeInFace(face, start, vertex, curve, nullptr,
curve->GetNaturalInterval(), SM_OT_SAME, 0.0,
edge, loop, split_face));
if (!edge || !edge->GetPrimaryEdgeuse()) throw Argument{};
SmEdgeuse* use = edge->GetPrimaryEdgeuse();
if (!use->GetVertexuse()) throw Argument{};
if (use->GetVertexuse()->GetVertex() != vertex) use = use->GetRadial();
// Safety invariant of this constructor, not an arithmetic parity assertion.
if (!use || !use->IsStrut() || !use->GetFaceuse()) throw Argument{};
source_use = use->GetFaceuse();
return vertex;
}
SmFace* circular_disk(SmContext& ctx, SmBrep* target, const SmPoint3d& center,
double radius) {
SmAxis2Placement placement;
placement.Translate(center);
SmBSplineCurve* circle = nullptr;
SmStatus status = SmBSplineCurve::CreateCircleSegment(ctx, 3, placement, radius,
0.0, 360.0, SM_CO_QUADRATIC, circle);
std::unique_ptr<SmCurve> circle_owner(circle);
constructed(status);
if (!circle) throw Argument{};
SmPoint3d point(0,0,0);
constructed(circle->EvaluatePoint(circle->GetNaturalInterval().GetMin(), point));
SmShell* shell = nullptr;
SmVertex* vertex = nullptr;
constructed(target->MakeShellVertex(nullptr, point, shell, vertex));
struct Pending {
SmCurve* p;
~Pending() { if (p && !p->GetOwner()) delete p; }
} pending{circle_owner.release()};
SmEdge* edge = nullptr;
constructed(target->MakeWireEdge(nullptr, vertex, vertex, pending.p,
circle->GetNaturalInterval(), SM_OT_SAME, edge));
if (!edge || !edge->GetPrimaryEdgeuse()) throw Argument{};
SmTArray<SmEdgeuse*> uses;
uses.Add(edge->GetPrimaryEdgeuse());
SmExtent2d domain(SmPoint2d(-radius,-radius), SmPoint2d(radius,radius));
std::unique_ptr<SmSurface> plane(new (ctx) SmPlane(center, SmVector3d(1,0,0),
SmVector3d(0,1,0), SmVector2d(1,1),
domain, &ctx));
return face_on_edges(target, std::move(plane), uses);
}
void put_vertex_surface(std::vector<double>& out, SmSurface* surface,
const std::vector<SmPoint2d>& samples) {
out.push_back(surface->GetType());
SmExtent2d domain = surface->GetNaturalUVDomain();
put_domain(out, domain);
// GetType is compared separately: never turn an analytic Sphere into a
// B-spline merely to make the samples agree.
SmBSplineSurface* spline = SM_CAST_PTR(SmBSplineSurface, surface);
gw_SURFACE* nurb = spline ? spline->GetGwNurbPointer() : nullptr;
out.push_back(nurb ? 1.0 : 0.0);
if (nurb) {
gw_INDEX n=nurb->net->n, m=nurb->net->m, r=nurb->knu->m, s=nurb->knv->m;
out.insert(out.end(), {(double)n, (double)m, (double)nurb->p,
(double)nurb->q, (double)r, (double)s});
for (gw_INDEX i=0; i<=n; ++i) for (gw_INDEX j=0; j<=m; ++j) {
const auto& point = nurb->net->Pw[i][j];
out.insert(out.end(), {point.x,point.y,point.z,point.w});
}
for (gw_INDEX i=0; i<=r; ++i) out.push_back(nurb->knu->U[i]);
for (gw_INDEX i=0; i<=s; ++i) out.push_back(nurb->knv->U[i]);
}
out.push_back(samples.size());
for (const auto& sample : samples) {
SmPoint2d uv((1.0-sample.x)*domain.GetMin().x + sample.x*domain.GetMax().x,
(1.0-sample.y)*domain.GetMin().y + sample.y*domain.GetMax().y);
SmPoint3d point(0,0,0);
SmVector3d du(0,0,0), dv(0,0,0), duv(0,0,0), duu(0,0,0), dvv(0,0,0);
SmStatus status = surface->Evaluate2ndDerivatives(uv, TRUE, TRUE,
point, du, dv, duv, duu, dvv);
out.push_back(status);
if (status != SM_SUCCESS) {
out.insert(out.end(), 18, 0.0);
} else {
put_point(out, point); put_point(out, du); put_point(out, dv);
put_point(out, duv); put_point(out, duu); put_point(out, dvv);
}
}
}
void vertex(Reader& rd, std::vector<double>& out) {
SmPoint3d point = rd.point();
double distance=rd.number(), approx_tol=rd.number();
double original_tol=rd.number(), result_tol=rd.number();
bool has_strut=rd.flag();
double radius=0.0, height=0.0;
bool map_mate=false;
if (has_strut) {
radius=rd.number(); height=rd.number(); map_mate=rd.flag();
for (double value : {point.x-2.0, point.x+2.0, point.y-2.0, point.y+2.0,
point.z+height, point.x+radius, point.x-radius,
point.y+radius, point.y-radius})
if (!std::isfinite(value)) throw Argument{};
}
std::vector<SmPoint2d> samples;
int64_t count=rd.index();
for (int64_t i=0; i<count; ++i) {
SmPoint2d sample=rd.uv();
if (sample.x<0 || sample.x>1 || sample.y<0 || sample.y>1) throw Argument{};
samples.push_back(sample);
}
rd.done();
SmContext ctx;
auto original=brep(ctx), offset=brep(ctx);
original->SetTolerance(original_tol, FALSE, FALSE);
offset->SetTolerance(result_tol, FALSE, FALSE);
SmVertex* source=nullptr;
SmFaceuse* source_use=nullptr;
SmFace* mapped_face=nullptr;
if (has_strut) {
source=source_strut(ctx, original.get(), point, source_use);
mapped_face=circular_disk(ctx, offset.get(), SmPoint3d(point.x,point.y,point.z+height), radius);
} else {
SmShell* shell=nullptr;
constructed(original->MakeShellVertex(nullptr, point, shell, source));
}
SmOffsetGeometryCreation geometry(distance, approx_tol);
Executive executive(ctx, SM_OO_SOLID_OFFSET, geometry, original.get());
executive.install(std::move(offset));
if (has_strut) {
if (map_mate) source_use=source_use->GetMate();
if (executive.relate_face(source_use, mapped_face) != SM_SUCCESS) throw Argument{};
}
VertexResult result;
SmStatus status=executive.BuildOffsetOfVertex(source, result.curves, result.orientations,
result.surface);
out.insert(out.end(), {0, (double)status, original->GetTolerance(),
executive.GetOffsetBrep()->GetTolerance(),
(double)result.curves.GetSize(), (double)result.orientations.GetSize(),
result.surface ? 1.0 : 0.0});
for (ULONG i=0; i<result.orientations.GetSize(); ++i) out.push_back(result.orientations[i]);
for (ULONG i=0; i<result.curves.GetSize(); ++i) {
SmCurve* curve=result.curves[i];
if (!curve) throw Argument{};
SmExtent1d interval=curve->GetNaturalInterval();
out.insert(out.end(), {(double)curve->GetType(), interval.GetMin(), interval.GetMax(), 4});
for (double fraction : {0.113,0.371,0.729,0.913}) {
double parameter=(1.0-fraction)*interval.GetMin()+fraction*interval.GetMax();
SmPoint3d point(0,0,0);
SmStatus status=curve->EvaluatePoint(parameter,point);
out.push_back(status);
if (status==SM_SUCCESS) put_point(out,point);
else out.insert(out.end(),3,0.0);
}
}
if (result.surface) put_vertex_surface(out, result.surface, samples);
}
void probe(Reader& rd, std::vector<double>& out) {
int64_t operation = rd.index(12);
double tol = rd.number();
rd.done();
SmContext ctx;
auto original = brep(ctx), offset = brep(ctx);
SmOffsetGeometryCreation geometry(0.25, tol);
Executive executive(ctx, SM_OO_SOLID_OFFSET, geometry, original.get());
executive.install(std::move(offset));
SmTArray<SmCurve*> curves;
SmTArray<SmOrientType> orientations;
SmSurface* surface = nullptr;
SmBrep* result = nullptr;
SmStatus status = SM_SUCCESS;
SmTArray<SmEdgeuse*> originals, offsets;
switch (operation) {
case 0: status = SmOffsetExecutive::ReplaceImplicitOffsets(original.get(), tol); break;
case 1: status = executive.RemoveExcessFaces(executive.GetOffsetBrep()); break;
case 2:
executive.SetMergeResults(TRUE);
status = executive.RemoveExcessFaces(executive.GetOffsetBrep()); break;
case 3: status = executive.BuildSideWallOfEdgeuse(nullptr); break;
case 4: status = executive.BuildSideWallOfEdgeuse(unit_wire(ctx, original.get(), 0)->GetPrimaryEdgeuse()); break;
case 5: {
SmTArray<SmEdgeuse*> gaps;
SmTArray<SmFace*> faces;
status = executive.FillGapEdgeuses(nullptr, gaps, faces); break;
}
case 6: status = executive.BuildOffsetOfVertex(nullptr, curves, orientations, surface); break;
case 7: {
SmShell* shell = nullptr;
SmVertex* vertex = nullptr;
constructed(original->MakeShellVertex(nullptr, SmPoint3d(0,0,0), shell, vertex));
status = executive.BuildOffsetOfVertex(vertex, curves, orientations, surface); break;
}
case 8: case 9: {
SmSSIData intersections;
SmFaceuse* use = nullptr;
if (operation == 9) use = plane_face(ctx, original.get(), 0)->GetUpwardFaceuse();
status = executive.BuildOffsetOfFaceuse(use, surface, intersections); break;
}
case 10: status = executive.PiecewiseMerge(result); break;
case 11: {
SmFace* face = plane_face(ctx, original.get(), 0);
status = executive.MapEdgeuses(face->GetUpwardFaceuse(), face);
original->GetEdgeuses(originals); offsets.Append(originals);
break;
}
case 12: {
SmFace* face = plane_face(ctx, original.get(), 0);
face->GetUpwardFaceuse()->GetEdgeuses(originals);
if (!originals.GetSize()) throw Argument{};
SmEdgeuse* use = originals[0];
if (!use->GetRadial()) throw Argument{};
status = executive.BuildOffsetOfEdgeuses(use, use->GetRadial(), SM_MT_MARK);
originals.ReSet();
break;
}
}
// PiecewiseMerge transfers ownership out of m_pOffsetBrep before stitching.
std::unique_ptr<SmBrep> result_owner(result);
std::unique_ptr<SmSurface> surface_owner(surface);
out.insert(out.end(), {0, (double)status, (double)curves.GetSize(), (double)orientations.GetSize(),
surface ? 1.0 : 0.0, result ? 1.0 : 0.0,
executive.GetOffsetBrep() ? 1.0 : 0.0});
out.push_back(originals.GetSize());
for (ULONG i=0; i<originals.GetSize(); ++i)
out.push_back(id(offsets, executive.GetOffsetEdgeuse(originals[i])));
for (ULONG i=0; i<curves.GetSize(); ++i) delete curves[i];
}
// Geometry handed to native constructors that may or may not adopt it: anything
// still unowned when the scope ends is the fixture's to delete.
struct Unowned {
std::vector<SmCurve*> curves;
SmSurface* surface = nullptr;
Unowned() = default;
Unowned(const Unowned&) = delete;
Unowned& operator=(const Unowned&) = delete;
~Unowned() {
for (SmCurve* c : curves) if (c && !c->GetOwner()) delete c;
if (surface && !surface->GetOwner()) delete surface;
}
};
SmPoint3d vertex_point(SmEdgeuse* use) {
if (!use || !use->GetVertexuse() || !use->GetVertexuse()->GetVertex()) throw Argument{};
return use->GetVertexuse()->GetVertex()->GetPoint();
}
// A plane face made by MakeFaceWithCurves from explicit 3D and UV lines
// (CreateFaceFromSurface's natural trim curves have no Rust fixture twin): the
// straight-edged loop `points` at height z on the plane with axes X, Y (or Y, X
// when `flip`, so its normal points down and UV is (y, x)), the plane's domain =
// the loop's UV bounding box.
SmFace* curve_face(SmContext& ctx, SmBrep* target, const std::vector<SmPoint2d>& points, double z,
bool flip) {
const size_t n = points.size();
if (n < 3) throw Argument{};
double x0 = points[0].x, y0 = points[0].y, x1 = x0, y1 = y0;
for (const SmPoint2d& p : points) {
x0 = std::min(x0, p.x); y0 = std::min(y0, p.y); x1 = std::max(x1, p.x); y1 = std::max(y1, p.y);
}
Unowned owned;
SmTArray<SmCurve*> curves3d;
SmTArray<SmBSplineCurve*> uv;
// MakeFaceWithCurves deletes the UV curves it is given (SmObjsDelete,
// SmBrep.cpp:15743), so they leave this guard when the call is made.
struct UvGuard {
SmTArray<SmBSplineCurve*>* list;
~UvGuard() { if (list) for (ULONG i=0; i<list->GetSize(); ++i) delete (*list)[i]; }
} uv_guard{&uv};
SmTArray<SmOrientType> orients;
SmTArray<SmPoint3d> vertex_points; // MakeFaceWithCurves loop points (none)
SmTArray<ULONG> loops;
SmExtent1d unit(0,1);
auto uv_of = [flip](double x, double y) { return flip ? SmPoint3d(y, x, 0) : SmPoint3d(x, y, 0); };
for (size_t i=0; i<n; ++i) {
const SmPoint2d& pa = points[i];
const SmPoint2d& pb = points[(i+1) % n];
SmPoint3d a(pa.x, pa.y, z), b(pb.x, pb.y, z);
SmLine* line = nullptr;
SmStatus status = SmLine::CreateLineSegment(ctx, 3, a, b, line, &unit);
owned.curves.push_back(line);
constructed(status);
SmBSplineCurve* trim = nullptr;
status = SmBSplineCurve::CreateLineSegment(ctx, 2, uv_of(a.x, a.y), uv_of(b.x, b.y), trim);
uv.Add(trim); // deleted with the array until handed to MakeFaceWithCurves
constructed(status);
if (!line || !trim) throw std::bad_alloc();
curves3d.Add(line); orients.Add(SM_OT_SAME);
}
loops.Add((ULONG)n);
SmExtent2d domain = flip ? SmExtent2d(SmPoint2d(y0, x0), SmPoint2d(y1, x1))
: SmExtent2d(SmPoint2d(x0, y0), SmPoint2d(x1, y1));
owned.surface = new (ctx) SmPlane(SmPoint3d(0,0,z), flip ? SmVector3d(0,1,0) : SmVector3d(1,0,0),
flip ? SmVector3d(1,0,0) : SmVector3d(0,1,0),
SmVector2d(1,1), domain, &ctx);
SmRegion* region = nullptr;
SmShell* shell = nullptr;
SmFace* face = nullptr;
uv_guard.list = nullptr;
constructed(target->MakeFaceWithCurves(target->GetInfiniteRegion(), loops, &curves3d, &uv,
orients, vertex_points, owned.surface, domain, SM_OT_SAME,
region, shell, face));
if (!face || !face->GetUpwardFaceuse() || !face->GetUpwardFaceuse()->GetMate())
throw Argument{};
return face;
}
// The loop of a rectangle, counter-clockwise from its lower-left corner, with the
// bottom edge split at `split` when given.
std::vector<SmPoint2d> rectangle_loop(const SmExtent2d& rect, const double* split) {
const double x0 = rect.GetMin().x, y0 = rect.GetMin().y, x1 = rect.GetMax().x, y1 = rect.GetMax().y;
std::vector<SmPoint2d> points{SmPoint2d(x0, y0)};
if (split) points.push_back(SmPoint2d(*split, y0));
points.insert(points.end(), {SmPoint2d(x1, y0), SmPoint2d(x1, y1), SmPoint2d(x0, y1)});
return points;
}
SmFace* curve_face(SmContext& ctx, SmBrep* target) {
return curve_face(ctx, target, rectangle_loop(SmExtent2d(SmPoint2d(0,0), SmPoint2d(1,1)), nullptr),
0.0, false);
}
// Per original edge use of `use`, sorted by the use's own start point (GetEdgeuses
// starts a loop at a construction-dependent use): start xyz, then -1 when
// GetOffsetEdgeuse is null, else 1 and the start points of the offset use and of
// its mate.
void put_mapped_uses(std::vector<double>& out, Executive& executive, SmFaceuse* use) {
SmTArray<SmEdgeuse*> uses;
use->GetEdgeuses(uses);
std::vector<std::vector<double>> records;
for (ULONG i=0; i<uses.GetSize(); ++i) {
std::vector<double> record;
put_point(record, vertex_point(uses[i]));
SmEdgeuse* mapped = executive.GetOffsetEdgeuse(uses[i]);
if (!mapped) { record.push_back(-1); }
else {
record.push_back(1);
put_point(record, vertex_point(mapped));
put_point(record, vertex_point(mapped->GetMate()));
}
records.push_back(record);
}
std::sort(records.begin(), records.end());
out.push_back((double)records.size());
for (auto& r : records) out.insert(out.end(), r.begin(), r.end());
}
// BuildOffsetOfFaceuse with a real offset plane z = distance over the given domain.
// Input: distance, approx_tol, domain, local, extend, merge, mate, then a selector
// 0 / 1 / 2 and that many UV segments of one self-intersection: the 3D line at
// z = distance runs along the first segment; the second UV curve is the same line
// (selector 1) or the second segment (selector 2). Output: status, the related
// faces (edge count and UV domain each, sorted by domain), offset B-rep
// face/edge/vertex counts, its sorted vertex points, then per original edge use
// (sorted by its start point) GetOffsetEdgeuse's end points.
void face_tail(Reader& rd, std::vector<double>& out) {
double distance = rd.number(), tol = rd.number();
SmExtent2d domain = rd.domain();
bool local = rd.flag(), extend = rd.flag(), merge = rd.flag(), mate = rd.flag();
int64_t segments = rd.index(2);
bool has_ssi = segments > 0;
SmPoint2d s0(0,0), s1(0,0), t0(0,0), t1(0,0);
if (has_ssi) { s0 = rd.uv(); s1 = rd.uv(); t0 = s0; t1 = s1; }
if (segments == 2) { t0 = rd.uv(); t1 = rd.uv(); }
rd.done();
SmContext ctx;
auto original = brep(ctx), offset = brep(ctx);
SmFace* face = curve_face(ctx, original.get());
SmFaceuse* use = face->GetUpwardFaceuse();
if (mate) use = use->GetMate();
SmOffsetGeometryCreation geometry(distance, tol);
Executive executive(ctx, local ? SM_OO_LOCAL_OPERATION : SM_OO_SOLID_OFFSET, geometry,
original.get());
executive.install(std::move(offset));
executive.SetExtendConvexEdges(extend ? TRUE : FALSE);
executive.SetMergeResults(merge ? TRUE : FALSE);
// Declared after the executive: checks ownership before the offset B-rep dies.
Unowned owned;
SmSSIData intersections;
if (has_ssi) {
SmExtent1d unit(0,1);
SmLine* line = nullptr;
SmStatus status = SmLine::CreateLineSegment(ctx, 3, SmPoint3d(s0.x, s0.y, distance),
SmPoint3d(s1.x, s1.y, distance), line, &unit);
owned.curves.push_back(line);
constructed(status);
intersections.m_v3DCurves.Add(line);
for (int i=0; i<2; ++i) {
SmBSplineCurve* trim = nullptr;
const SmPoint2d& a = i ? t0 : s0;
const SmPoint2d& b = i ? t1 : s1;
status = SmBSplineCurve::CreateLineSegment(ctx, 2, SmPoint3d(a.x, a.y, 0),
SmPoint3d(b.x, b.y, 0), trim);
owned.curves.push_back(trim);
constructed(status);
(i ? intersections.m_vUVCurves2 : intersections.m_vUVCurves1).Add(trim);
}
}
owned.surface = new (ctx) SmPlane(SmPoint3d(0,0,distance), SmVector3d(1,0,0),
SmVector3d(0,1,0), SmVector2d(1,1), domain, &ctx);
SmSurface* surface = owned.surface;
SmStatus status = executive.BuildOffsetOfFaceuse(use, surface, intersections);
out.insert(out.end(), {0, (double)status});
SmTArray<SmFace*> related;
executive.faces_of(use, related);
std::vector<std::vector<double>> summaries;
for (ULONG i=0; i<related.GetSize(); ++i) {
SmTArray<SmEdge*> edges;
related[i]->GetEdges(edges);
SmExtent2d d = related[i]->GetUVDomain();
summaries.push_back({d.GetMin().x, d.GetMin().y, d.GetMax().x, d.GetMax().y,
(double)edges.GetSize()});
}
std::sort(summaries.begin(), summaries.end());
out.push_back((double)summaries.size());
for (auto& v : summaries) out.insert(out.end(), v.begin(), v.end());
SmBrep* result = executive.GetOffsetBrep();
if (!result) throw Argument{};
SmTArray<SmFace*> faces;
SmTArray<SmEdge*> edges;
SmTArray<SmVertex*> vertices;
result->GetFaces(faces); result->GetEdges(edges); result->GetVertices(vertices);
out.insert(out.end(), {(double)faces.GetSize(), (double)edges.GetSize(),
(double)vertices.GetSize()});
std::vector<std::vector<double>> points;
for (ULONG i=0; i<vertices.GetSize(); ++i) {
SmPoint3d p = vertices[i]->GetPoint();
points.push_back({p.x, p.y, p.z});
}
std::sort(points.begin(), points.end());
for (auto& p : points) out.insert(out.end(), p.begin(), p.end());
put_mapped_uses(out, executive, use);
}
// MapEdgeuses alone, on two MakeFaceWithCurves faces: the original rectangle at
// z = 0 and an offset rectangle at z = distance (its plane flipped when asked),
// matching the upward or downward original use. Input: distance, original rect,
// offset rect, flip, mate, then a flag and optionally the x at which the offset
// rectangle's bottom edge is split into two collinear edges. Output: status, then
// per original edge use (sorted by its start point) GetOffsetEdgeuse's end points
// as in face_tail.
void map_twin(Reader& rd, std::vector<double>& out) {
double distance = rd.number();
SmExtent2d original_rect = rd.domain(), offset_rect = rd.domain();
bool flip = rd.flag(), mate = rd.flag(), has_split = rd.flag();
double split = 0;
if (has_split) {
split = rd.number();
if (!(offset_rect.GetMin().x < split && split < offset_rect.GetMax().x)) throw Argument{};
}
rd.done();
SmContext ctx;
auto original = brep(ctx), offset = brep(ctx);
SmFace* face = curve_face(ctx, original.get(), rectangle_loop(original_rect, nullptr), 0.0, false);
SmFace* twin = curve_face(ctx, offset.get(), rectangle_loop(offset_rect, has_split ? &split : nullptr),
distance, flip);
SmFaceuse* use = face->GetUpwardFaceuse();
if (mate) use = use->GetMate();
SmOffsetGeometryCreation geometry(distance, 1e-6);
Executive executive(ctx, SM_OO_SOLID_OFFSET, geometry, original.get());
executive.install(std::move(offset));
SmStatus status = executive.MapEdgeuses(use, twin);
out.insert(out.end(), {0, (double)status});
put_mapped_uses(out, executive, use);
}
void replace(Reader& rd, std::vector<double>& out) {
SmContext ctx;
int64_t base_kind = rd.index(1);
std::unique_ptr<SmSurface> base;
if (base_kind == 0) {
base = read_surface(rd, ctx);
} else {
std::unique_ptr<SmCurve> curve = read_curve(rd, ctx);
SmBSplineCurve* generator = SM_CAST_PTR(SmBSplineCurve, curve.get());
if (!generator) throw Argument{};
SmPoint3d origin = rd.point();
SmVector3d direction = rd.point();
SmExtent2d domain = rd.domain();
bool swap = rd.flag();
// The extrusion owns its generator curve.
base.reset(new (ctx) SmSurfOfExtrusion(generator, origin, direction, domain,
swap ? TRUE : FALSE));
curve.release();
}
double distance = rd.number(), tol = rd.number();
int64_t nsamples = rd.index(64);
std::vector<SmPoint2d> samples;
for (int64_t i=0; i<nsamples; ++i) {
SmPoint2d sample = rd.uv();
if (sample.x<0 || sample.x>1 || sample.y<0 || sample.y>1) throw Argument{};
samples.push_back(sample);
}
rd.done();
auto original = brep(ctx);
struct Pending {
SmSurface* p;
~Pending() { if (p && !p->GetOwner()) delete p; }
} pending{new (ctx) SmOffsetSurface(distance, *base, TRUE)};
base.release();
SmExtent2d natural = pending.p->GetNaturalUVDomain();
SmFace* face = nullptr;
constructed(original->CreateFaceFromSurface(pending.p, natural, face));
if (!face) throw Argument{};
SmStatus status = SmOffsetExecutive::ReplaceImplicitOffsets(original.get(), tol);
SmTArray<SmFace*> faces;
original->GetFaces(faces);
out.insert(out.end(), {0, (double)status, (double)faces.GetSize()});
for (ULONG i=0; i<faces.GetSize(); ++i) {
SmSurface* surface = faces[i]->GetSurface();
out.push_back(surface ? (double)surface->GetType() : -1.0);
put_domain(out, faces[i]->GetUVDomain());
if (!surface) continue;
SmExtent2d domain = surface->GetNaturalUVDomain();
put_domain(out, domain);
out.push_back((double)samples.size());
for (const SmPoint2d& f : samples) {
SmPoint2d uv((1.0-f.x)*domain.GetMin().x + f.x*domain.GetMax().x,
(1.0-f.y)*domain.GetMin().y + f.y*domain.GetMax().y);
SmPoint3d point(0,0,0);
SmStatus eval = surface->EvaluatePoint(uv, point);
out.push_back(eval);
if (eval == SM_SUCCESS) put_point(out, point);
else out.insert(out.end(), 3, 0.0);
}
}
}
} // namespace
// Plain-C ABI, mode 0 config / 1 synchronize / 2 extend / 3 probe / 4 face tail /
// 5 map twin / 6 vertex / 7 replace.
// Caller owns every buffer; no native allocation or object address crosses it.
SC_EXPORT int32_t sc_offset_offset_executive_p1_eval(
int32_t mode, const double* input, int64_t input_len,
double* out, int64_t cap, int64_t* out_len) {
if (!out_len || cap < 0 || (cap && !out) || !input || input_len < 0 || input_len > max_values)
return SC_ERR_ARG;
try {
SC_NATIVE_LOCK;
Reader rd{input, input_len};
std::vector<double> result;
try {
switch (mode) {
case 0: config(rd, result); break;
case 1: synchronize(rd, result); break;
case 2: extend(rd, result); break;
case 3: probe(rd, result); break;
case 6: vertex(rd, result); break;
case 4: face_tail(rd, result); break;
case 5: map_twin(rd, result); break;
case 7: replace(rd, result); break;
default: throw Argument{};
}
} catch (const Rejected& rejection) {
result = {-1, (double)rejection.status};
}
return sc_copy_out(result.data(), (int64_t)result.size(), out, cap, out_len);
} catch (const Argument&) {
return SC_ERR_ARG;
} catch (...) {
return SC_ERR_EXCEPTION;
}
}
Reference in New Issue View Git Blame Copy Permalink