brep-io-kernel 1.0.97 → 1.0.99

package/src/features/sketch/sketchSolver2D/ConstraintEngine.js

@@ -5,12 +5,20 @@ import { distance, calculateAngle } from "./mathHelpersMod.js";
 
 // === Constraint function table ===
 const constraintFunctions = constraints.constraintFunctions;
+let globalDistanceSolveCycleId = 0;
 
 // === Engine that performs numeric solving on a sketch snapshot ===
 class ConstraintEngine {
     constructor(sketchJSON) {
         const sketch = JSON.parse(sketchJSON);
-        this.points = sketch.points.map(p => new Point(p.id, p.x, p.y, p.fixed));
+        this.points = sketch.points.map(p => new Point(
+            p.id,
+            p.x,
+            p.y,
+            p.fixed,
+            p.construction,
+            p.externalReference
+        ));
         this.geometries = sketch.geometries || [];
         this.constraints = sketch.constraints || [];
     }
@@ -63,6 +71,17 @@ class ConstraintEngine {
 
     solve(iterations = 100) {
         const decimalsPlaces = 6;
+        this._distanceSolveCycleId = ++globalDistanceSolveCycleId;
+        const hasPendingDistanceTargetSlides = () => {
+            const slideTol = Number.isFinite(constraints?.tolerance) ? Number(constraints.tolerance) : 1e-8;
+            return this.constraints.some((c) => (
+                c?.type === "⟺" &&
+                c?._distanceThrottleActive === true &&
+                Number.isFinite(c?._distanceRequestedTarget) &&
+                Number.isFinite(c?._distanceAppliedTarget) &&
+                Math.abs(c._distanceRequestedTarget - c._distanceAppliedTarget) > slideTol
+            ));
+        };
 
         // Implied constraints for certain geometry types (e.g., arcs, bezier splines)
         let nextTempId =
@@ -101,6 +120,7 @@ class ConstraintEngine {
         this.tidyDecimalsOfPoints(decimalsPlaces, true);
 
         // Ground first, then everything
+        this._distanceSolvePassToken = `${this._distanceSolveCycleId}:pre`;
         this.processConstraintsOfType("⏚");
         this.processConstraintsOfType("all");
 
@@ -114,6 +134,7 @@ class ConstraintEngine {
         let converged = false;
 
         for (let i = 0; i < iterations; i++) {
+            this._distanceSolvePassToken = `${this._distanceSolveCycleId}:${i}`;
             for (const t of order) {
                 this.processConstraintsOfType(t);
                 this.processConstraintsOfType("≡"); // keep coincident snapping frequently
@@ -126,7 +147,7 @@ class ConstraintEngine {
             }
 
             const cur = JSON.stringify(this.points);
-            if (cur === prev) {
+            if (cur === prev && !hasPendingDistanceTargetSlides()) {
                 converged = true;
                 break;
             }
@@ -150,7 +171,14 @@ class ConstraintEngine {
 
         // Return a new sketch object mirroring input structure
         const updatedSketch = {
-            points: this.points.map(p => ({ id: p.id, x: p.x, y: p.y, fixed: p.fixed })),
+            points: this.points.map(p => ({
+                id: p.id,
+                x: p.x,
+                y: p.y,
+                fixed: p.fixed,
+                construction: p.construction === true,
+                externalReference: p.externalReference === true
+            })),
             geometries: this.geometries,
             constraints: this.constraints.filter(c => !c.temporary) // drop temporaries
         };
@@ -160,11 +188,13 @@ class ConstraintEngine {
 }
 
 class Point {
-    constructor(id, x, y, fixed = false) {
+    constructor(id, x, y, fixed = false, construction = false, externalReference = false) {
         this.id = id;
         this.x = x;
         this.y = y;
         this.fixed = fixed;
+        this.construction = construction === true;
+        this.externalReference = externalReference === true;
     }
 }
 
@@ -188,7 +218,7 @@ export class ConstraintSolver {
         this.appState = opts.appState || { mode: "", type: "", requiredSelections: 0 };
 
         this.sketchObject = opts.sketch ? sanitizeSketch(opts.sketch) : {
-            points: [{ id: 0, x: 0, y: 0, fixed: true }],
+            points: [{ id: 0, x: 0, y: 0, fixed: true, construction: true, externalReference: false }],
             geometries: [],
             constraints: [{ id: 0, type: "⏚", points: [0] }]
         };
@@ -892,14 +922,19 @@ export class ConstraintSolver {
 function sanitizeSketch(sketch) {
     const s = {
         points: Array.isArray(sketch.points) ? sketch.points.map(p => ({
-            id: +p.id, x: +p.x, y: +p.y, fixed: !!p.fixed
+            id: +p.id,
+            x: +p.x,
+            y: +p.y,
+            fixed: !!p.fixed,
+            construction: (typeof p?.construction === "boolean") ? p.construction : (+p?.id === 0),
+            externalReference: !!p?.externalReference
         })) : [],
         geometries: Array.isArray(sketch.geometries) ? sketch.geometries.slice() : [],
         constraints: Array.isArray(sketch.constraints) ? sketch.constraints.slice() : []
     };
 
     // Ensure at least an origin and ground if empty
-    if (s.points.length === 0) s.points.push({ id: 0, x: 0, y: 0, fixed: true });
+    if (s.points.length === 0) s.points.push({ id: 0, x: 0, y: 0, fixed: true, construction: true, externalReference: false });
     if (!s.constraints.some(c => c.type === "⏚")) {
         s.constraints.push({ id: 0, type: "⏚", points: [0] });
     }

package/src/features/sketch/sketchSolver2D/constraintDefinitions.js

@@ -1,6 +1,9 @@
 "use strict";
 import { calculateAngle, rotatePoint, distance, roundToDecimals } from "./mathHelpersMod.js";
 let tolerance = 0.00001;
+let distanceSlideThresholdRatio = 0.10;
+let distanceSlideStepRatio = 0.10;
+let distanceSlideMinStep = 0.001;
 const constraintFunctions = [];
 
 const normalizeAngle = (angle) => ((angle % 360) + 360) % 360;
@@ -9,6 +12,88 @@ const shortestAngleDelta = (target, current) => {
     return (delta > 180) ? delta - 360 : delta;
 };
 
+function relativeDeltaRatio(a, b, floor = tolerance) {
+    const denom = Math.max(Math.abs(a), Math.abs(b), floor);
+    return Math.abs(a - b) / denom;
+}
+
+function resolveDistanceTargetForSolvePass(solverObject, constraint, requestedTarget) {
+    if (constraint?.type !== "⟺" || !Number.isFinite(requestedTarget)) {
+        return requestedTarget;
+    }
+
+    const previousRequested = Number.isFinite(constraint._distanceRequestedTarget)
+        ? constraint._distanceRequestedTarget
+        : null;
+
+    let appliedTarget = Number.isFinite(constraint._distanceAppliedTarget)
+        ? constraint._distanceAppliedTarget
+        : (previousRequested ?? requestedTarget);
+
+    const targetChanged = previousRequested !== null &&
+        Math.abs(requestedTarget - previousRequested) > tolerance;
+
+    if (previousRequested === null) {
+        constraint._distanceThrottleActive = false;
+        appliedTarget = requestedTarget;
+    } else if (targetChanged) {
+        const rel = relativeDeltaRatio(requestedTarget, previousRequested, tolerance);
+        if (rel > distanceSlideThresholdRatio) {
+            constraint._distanceThrottleActive = true;
+        } else {
+            constraint._distanceThrottleActive = false;
+            appliedTarget = requestedTarget;
+        }
+    }
+
+    constraint._distanceRequestedTarget = requestedTarget;
+
+    if (!constraint._distanceThrottleActive) {
+        constraint._distanceAppliedTarget = requestedTarget;
+        return requestedTarget;
+    }
+
+    const solvePassToken = (typeof solverObject?._distanceSolvePassToken === "string")
+        ? solverObject._distanceSolvePassToken
+        : null;
+    const lastAppliedPassToken = (typeof constraint._distanceLastAppliedPassToken === "string")
+        ? constraint._distanceLastAppliedPassToken
+        : null;
+
+    if (solvePassToken !== null && lastAppliedPassToken === solvePassToken) {
+        return Number.isFinite(constraint._distanceAppliedTarget)
+            ? constraint._distanceAppliedTarget
+            : appliedTarget;
+    }
+
+    const delta = requestedTarget - appliedTarget;
+    const absDelta = Math.abs(delta);
+    if (absDelta <= tolerance) {
+        constraint._distanceThrottleActive = false;
+        constraint._distanceAppliedTarget = requestedTarget;
+        if (solvePassToken !== null) constraint._distanceLastAppliedPassToken = solvePassToken;
+        return requestedTarget;
+    }
+
+    // Scale slide speed by the remaining gap so large drops (e.g. 1000 -> 1)
+    // can still settle within a single solve evaluation.
+    const maxStep = Math.max(
+        distanceSlideMinStep,
+        absDelta * distanceSlideStepRatio
+    );
+    const step = Math.min(absDelta, maxStep);
+    appliedTarget += Math.sign(delta) * step;
+
+    if (Math.abs(requestedTarget - appliedTarget) <= tolerance) {
+        appliedTarget = requestedTarget;
+        constraint._distanceThrottleActive = false;
+    }
+
+    constraint._distanceAppliedTarget = appliedTarget;
+    if (solvePassToken !== null) constraint._distanceLastAppliedPassToken = solvePassToken;
+    return appliedTarget;
+}
+
 
 (constraintFunctions["━"] = function (solverObject, constraint, points, constraintValue) {
     // Horizontal constraint
@@ -74,8 +159,15 @@ const shortestAngleDelta = (target, current) => {
     if (isNaN(constraintValue) | constraintValue == undefined | constraintValue == null) {
         targetDistance = currentDistance;
         constraint.value = currentDistance;
+        if (constraint?.type === "⟺") {
+            constraint._distanceRequestedTarget = currentDistance;
+            constraint._distanceAppliedTarget = currentDistance;
+            constraint._distanceThrottleActive = false;
+            constraint._distanceLastAppliedPassToken = null;
+        }
     }
 
+    targetDistance = resolveDistanceTargetForSolvePass(solverObject, constraint, targetDistance);
 
 
     let diff = roundToDecimals(Math.abs(targetDistance) - currentDistance, 4);
@@ -691,6 +783,18 @@ const shortestAngleDelta = (target, current) => {
 export const constraints = {
     get tolerance() { return tolerance; },
     set tolerance(value) { tolerance = value; },
+    get distanceSlideThresholdRatio() { return distanceSlideThresholdRatio; },
+    set distanceSlideThresholdRatio(value) {
+        if (Number.isFinite(value) && value >= 0) distanceSlideThresholdRatio = Number(value);
+    },
+    get distanceSlideStepRatio() { return distanceSlideStepRatio; },
+    set distanceSlideStepRatio(value) {
+        if (Number.isFinite(value) && value >= 0) distanceSlideStepRatio = Number(value);
+    },
+    get distanceSlideMinStep() { return distanceSlideMinStep; },
+    set distanceSlideMinStep(value) {
+        if (Number.isFinite(value) && value >= 0) distanceSlideMinStep = Number(value);
+    },
     constraintFunctions,
 };
 

package/src/tests/fixtures/sketchSolverTopology/README.md

@@ -0,0 +1,46 @@
+# Sketch Solver Topology Fixtures
+
+Drop `.json` files in this folder to add sketch-solver topology regression tests automatically.
+
+Each file becomes its own test in `pnpm test` via `registerSketchSolverTopologyFixtureTests(...)`.
+
+## Fixture schema
+
+```json
+{
+  "name": "rect_width_height_fixture",
+  "sketch": { "points": [], "geometries": [], "constraints": [] },
+  "sourcePartFile": "src/tests/partFiles/your_case.BREP.json",
+  "sourceFeatureId": "S1",
+  "initialSolvePasses": 4,
+  "edits": [
+    { "constraintId": 5, "value": 110 },
+    { "expressionValues": { "x": 1200, "y": 2500, "z": 300 } }
+  ],
+  "expect": {
+    "topologyUnchanged": true,
+    "distances": [
+      { "a": 0, "b": 1, "value": 110, "tol": 0.06 }
+    ],
+    "anchors": [
+      { "pointId": 0, "x": 0, "y": 0, "tol": 0.01 }
+    ],
+    "coincidentPairs": [
+      { "a": 1, "b": 2, "tol": 0.01 }
+    ],
+    "orientationLoops": [
+      { "pointIds": [0, 1, 2, 3], "preserveSign": true, "minAbsArea": 1.0 }
+    ]
+  }
+}
+```
+
+## Notes
+
+- Provide either `sketch` directly, or `sourcePartFile` (optional `sourceFeatureId`) to pull a sketch from an existing part file.
+- `edits` are applied in order; solver runs after each edit.
+- `constraintId/value` edits set one dimension directly.
+- `expressionValues` edits evaluate every `constraint.valueExpr` using provided variables (useful for `x/y/z` expression-driven sketches).
+- If `expect.topologyUnchanged` is omitted, it defaults to `true`.
+- `tol` defaults to `0.01` when omitted.
+- A fixture fails fast with a clear message if IDs are invalid or references break.

package/src/tests/fixtures/sketchSolverTopology/coincident_chain_fixture.json

@@ -0,0 +1,48 @@
+{
+  "name": "coincident_chain_fixture",
+  "sketch": {
+    "points": [
+      { "id": 0, "x": 0, "y": 0, "fixed": true },
+      { "id": 1, "x": 40, "y": 0, "fixed": false },
+      { "id": 2, "x": 40, "y": 0, "fixed": false },
+      { "id": 3, "x": 40, "y": 30, "fixed": false },
+      { "id": 4, "x": 40, "y": 30, "fixed": false },
+      { "id": 5, "x": 80, "y": 30, "fixed": false }
+    ],
+    "geometries": [
+      { "id": 200, "type": "line", "points": [0, 1], "construction": false },
+      { "id": 201, "type": "line", "points": [2, 3], "construction": false },
+      { "id": 202, "type": "line", "points": [4, 5], "construction": false }
+    ],
+    "constraints": [
+      { "id": 0, "type": "⏚", "points": [0] },
+      { "id": 10, "type": "≡", "points": [1, 2] },
+      { "id": 11, "type": "≡", "points": [3, 4] },
+      { "id": 12, "type": "━", "points": [0, 1] },
+      { "id": 13, "type": "│", "points": [2, 3] },
+      { "id": 14, "type": "━", "points": [4, 5] },
+      { "id": 15, "type": "⟺", "points": [0, 1], "value": 40 },
+      { "id": 16, "type": "⟺", "points": [2, 3], "value": 30 },
+      { "id": 17, "type": "⟺", "points": [4, 5], "value": 40 }
+    ]
+  },
+  "edits": [
+    { "constraintId": 16, "value": 75 },
+    { "constraintId": 15, "value": 60 }
+  ],
+  "expect": {
+    "topologyUnchanged": true,
+    "distances": [
+      { "a": 0, "b": 1, "value": 60, "tol": 0.1 },
+      { "a": 2, "b": 3, "value": 75, "tol": 0.1 },
+      { "a": 4, "b": 5, "value": 40, "tol": 0.1 }
+    ],
+    "anchors": [
+      { "pointId": 0, "x": 0, "y": 0, "tol": 0.02 }
+    ],
+    "coincidentPairs": [
+      { "a": 1, "b": 2, "tol": 0.02 },
+      { "a": 3, "b": 4, "tol": 0.02 }
+    ]
+  }
+}

package/src/tests/fixtures/sketchSolverTopology/rect_width_height_fixture.json

@@ -0,0 +1,43 @@
+{
+  "name": "rect_width_height_fixture",
+  "sketch": {
+    "points": [
+      { "id": 0, "x": 0, "y": 0, "fixed": true },
+      { "id": 1, "x": 40, "y": 0, "fixed": false },
+      { "id": 2, "x": 40, "y": 20, "fixed": false },
+      { "id": 3, "x": 0, "y": 20, "fixed": false }
+    ],
+    "geometries": [
+      { "id": 100, "type": "line", "points": [0, 1], "construction": false },
+      { "id": 101, "type": "line", "points": [1, 2], "construction": false },
+      { "id": 102, "type": "line", "points": [2, 3], "construction": false },
+      { "id": 103, "type": "line", "points": [3, 0], "construction": false }
+    ],
+    "constraints": [
+      { "id": 0, "type": "⏚", "points": [0] },
+      { "id": 1, "type": "━", "points": [0, 1] },
+      { "id": 2, "type": "━", "points": [2, 3] },
+      { "id": 3, "type": "│", "points": [1, 2] },
+      { "id": 4, "type": "│", "points": [3, 0] },
+      { "id": 5, "type": "⟺", "points": [0, 1], "value": 40 },
+      { "id": 6, "type": "⟺", "points": [1, 2], "value": 20 }
+    ]
+  },
+  "edits": [
+    { "constraintId": 5, "value": 110 },
+    { "constraintId": 6, "value": 45 }
+  ],
+  "expect": {
+    "topologyUnchanged": true,
+    "distances": [
+      { "a": 0, "b": 1, "value": 110, "tol": 0.08 },
+      { "a": 1, "b": 2, "value": 45, "tol": 0.08 }
+    ],
+    "anchors": [
+      { "pointId": 0, "x": 0, "y": 0, "tol": 0.02 }
+    ],
+    "orientationLoops": [
+      { "pointIds": [0, 1, 2, 3], "preserveSign": true, "minAbsArea": 1.0 }
+    ]
+  }
+}

package/src/tests/fixtures/sketchSolverTopology/sketch_throttel_expression_sequence_fixture.json

@@ -0,0 +1,25 @@
+{
+  "name": "sketch_throttel_expression_sequence_fixture",
+  "sourcePartFile": "src/tests/partFiles/sketch_throttel_testing.BREP.json",
+  "sourceFeatureId": "S1",
+  "initialSolvePasses": 4,
+  "edits": [
+    { "expressionValues": { "x": 10, "y": 20, "z": 10 } },
+    { "expressionValues": { "x": 1200, "y": 2500, "z": 300 } }
+  ],
+  "expect": {
+    "topologyUnchanged": true,
+    "distances": [
+      { "a": 7, "b": 2, "value": 1200, "tol": 0.2 },
+      { "a": 5, "b": 6, "value": 2500, "tol": 0.2 }
+    ],
+    "anchors": [
+      { "pointId": 0, "x": 0, "y": 0, "tol": 0.02 }
+    ],
+    "coincidentPairs": [
+      { "a": 1, "b": 2, "tol": 0.02 },
+      { "a": 3, "b": 4, "tol": 0.02 },
+      { "a": 6, "b": 7, "tol": 0.02 }
+    ]
+  }
+}