@stemy/ngx-utils 19.7.2 → 19.7.5

package/fesm2022/stemy-ngx-utils.mjs

@@ -1895,36 +1895,64 @@ const MAX_ITERS = 40;
 // GJK distance (robust)
 // =========================
 function gjkDistance(A, B) {
-    let intersection = gjkIntersection(A, B);
-    if (intersection.hit)
-        return { distance: 0 };
+    // 1) Quick overlap
+    const inter = gjkIntersection(A, B);
+    if (inter.hit) {
+        // Pass through pa/pb
+        return { distance: 0, pa: inter.pa ?? null, pb: inter.pb ?? null };
+    }
     const ca = A.center;
     const cb = B.center;
+    // 2) Bisection along the center-line to find the first hit pose
     let s = 0;
     let e = 1;
-    let center = ca;
     let iters = 0;
-    while (e - s > EPSILON) {
+    // Keep the best "hit" snapshot and its center so we can map witnesses back
+    let hitSnap = null;
+    let hitCenter = ca;
+    while ((e - s) > EPSILON && iters < MAX_ITERS) {
         iters++;
-        const t = (e + s) / 2;
-        const a = A.move(lerpPts(ca, cb, t));
-        const test = gjkIntersection(a, B);
-        center = a.center;
+        const t = (e + s) * 0.5;
+        // Assumes A.move(newCenter) returns a NEW shape whose center is exactly this point
+        const aMoved = A.move(lerpPts(ca, cb, t));
+        const test = gjkIntersection(aMoved, B);
         if (test.hit) {
-            intersection = test;
-            e = t;
-            if (iters >= MAX_ITERS)
-                break;
+            hitSnap = test;
+            hitCenter = aMoved.center;
+            e = t; // shrink toward contact
         }
         else {
-            s = t;
+            s = t; // still separated
         }
     }
-    const result = distance(ca, center);
+    // 3) Make sure we end with a hit snapshot (in case we stopped on iteration cap)
+    if (!hitSnap) {
+        const aMoved = A.move(lerpPts(ca, cb, e));
+        const test = gjkIntersection(aMoved, B);
+        if (test.hit) {
+            hitSnap = test;
+            hitCenter = aMoved.center;
+        }
+        else {
+            // Extremely degenerate: no hit even at e ~ 1 (shouldn't happen for non-degenerate shapes).
+            // Fall back to center-line direction as a last resort.
+            const dir = normalizePt(subPts(cb, ca));
+            const pa0 = A.support(dir);
+            const pb0 = B.support(negatePt(dir));
+            return { distance: distance(pa0, pb0), pa: pa0, pb: pb0 };
+        }
+    }
+    // 4) Map witnesses back to the original A pose
+    //    (We moved A by (hitCenter - ca); to undo, offset A's witness by (ca - hitCenter))
+    const offset = subPts(ca, hitCenter);
+    const pa0 = addPts(hitSnap.pa, offset);
+    const pb0 = hitSnap.pb;
+    // 5) True geometric separation is the distance between these boundary points
+    const d = distance(pa0, pb0);
     return {
-        distance: result,
-        pa: result > 0 ? addPts(intersection.pa, subPts(ca, center)) : null,
-        pb: result > 0 ? intersection.pb : null
+        distance: d,
+        pa: d > 0 ? pa0 : null,
+        pb: d > 0 ? pb0 : null
     };
 }
 // =========================
@@ -2010,20 +2038,20 @@ function doSimplexBoolean(simplex, d) {
     const A = last, B = simplex[simplex.length - 2], C = simplex[simplex.length - 3];
     const AB = { x: B.p.x - A.p.x, y: B.p.y - A.p.y };
     const AC = { x: C.p.x - A.p.x, y: C.p.y - A.p.y };
-    const ABperp = tripleProduct(AC, AB, AB);
-    const ACperp = tripleProduct(AB, AC, AC);
+    const perpAB = tripleProduct(AC, AB, AB);
+    const perpAC = tripleProduct(AB, AC, AC);
     // If origin is outside AB region
-    if (ABperp.x * AO.x + ABperp.y * AO.y > 0) {
+    if (perpAB.x * AO.x + perpAB.y * AO.y > 0) {
         simplex.splice(simplex.length - 3, 1);
-        d.x = ABperp.x;
-        d.y = ABperp.y;
+        d.x = perpAB.x;
+        d.y = perpAB.y;
         return { hit: false };
     }
     // If origin is outside AC region
-    if (ACperp.x * AO.x + ACperp.y * AO.y > 0) {
+    if (perpAC.x * AO.x + perpAC.y * AO.y > 0) {
         simplex.splice(simplex.length - 2, 1);
-        d.x = ACperp.x;
-        d.y = ACperp.y;
+        d.x = perpAC.x;
+        d.y = perpAC.y;
         return { hit: false };
     }
     // Otherwise the origin is inside the triangle → overlap
@@ -3768,8 +3796,9 @@ class FormatterService {
         precision = this.getPrecision(precision);
         minDigits = minDigits ?? precision;
         divider = divider || this.defaultDivider;
-        const num = ObjectUtils.isNumber(value) ? value : parseFloat(value) || 0;
-        const str = (num / divider).toLocaleString(this.language.currentLanguage, {
+        const num = (ObjectUtils.isNumber(value) ? value : parseFloat(value) ?? 0) / divider;
+        const rounded = isNaN(num) ? 0 : MathUtils.round(0, 12);
+        const str = rounded.toLocaleString(this.language.currentLanguage, {
             minimumFractionDigits: minDigits,
             maximumFractionDigits: precision,
             useGrouping: false
@@ -7851,8 +7880,8 @@ class InteractiveItemComponent {
     }
     isValidByParams() {
         return !this.shapes.some(shape => {
-            return this.canvas.exclusions.some(ex => {
-                return shape.distance(ex) < 1;
+            return this.canvas.excludedAreas.some(ex => {
+                return shape.intersects(ex);
             });
         });
     }
@@ -7949,7 +7978,7 @@ class InteractiveCanvasComponent {
         this.rotation = 0;
         this.basePan = 0;
         this.cycles = [0];
-        this.exclusions = [];
+        this.excludedAreas = [];
         this.touched = false;
         this.panStartRotation = 0;
         this.panStartPos = Point.Zero;
@@ -8091,11 +8120,11 @@ class InteractiveCanvasComponent {
             + this.canvasHeight * this.panOffset;
         this.cycles = this.infinite
             ? [this.basePan - this.fullHeight, this.basePan, this.basePan + this.fullHeight] : [0];
-        this.exclusions = (this.params.exclusions || []).flatMap(coords => {
-            const x = (coords[2] + coords[0]) * .5 * this.ratio;
-            const y = (coords[3] + coords[1]) * .5 * this.ratio;
-            const width = Math.abs(coords[2] - coords[0]) * this.ratio;
-            const height = Math.abs(coords[3] - coords[1]) * this.ratio;
+        this.excludedAreas = (this.params.excludedAreas || []).flatMap(coords => {
+            const x = coords.x * this.ratio;
+            const y = coords.y * this.ratio;
+            const width = coords.width * this.ratio;
+            const height = coords.height * this.ratio;
             return this.cycles.map(cycle => {
                 return new Rect(x, y + cycle, width, height);
             });