fixed scaling issues with hex grid on face, improved fillet code, added extra functions to points class to determine what is the safe radius between three points both in full and in half-line situations.

Author: matas-bitbybit-dev

packages/dev/base/lib/api/inputs/point-inputs.ts

@@ -411,6 +411,62 @@ export namespace Point {
          */
         reverseNormal = false;
     }
+    export class ThreePointsToleranceDto {
+        constructor(start?: Base.Point3, center?: Base.Point3, end?: Base.Point3, tolerance?: number) {
+            if (start !== undefined) { this.start = start; }
+            if (center !== undefined) { this.center = center; }
+            if (end !== undefined) { this.end = end; }
+            if (tolerance !== undefined) { this.tolerance = tolerance; }
+        }
+        /**
+         * Start point
+         * @default undefined
+         */
+        start?: Base.Point3;
+        /**
+         * Center point
+         * @default undefined
+         */
+        center?: Base.Point3;
+        /**
+         * End point
+         * @default undefined
+         */
+        end?: Base.Point3;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance = 1e-7;
+    }
+    export class PointsMaxFilletsHalfLineDto {
+        constructor(points?: Base.Point3[], checkLastWithFirst?: boolean, tolerance?: number) {
+            if (points !== undefined) { this.points = points; }
+            if (checkLastWithFirst !== undefined) { this.checkLastWithFirst = checkLastWithFirst; }
+            if (tolerance !== undefined) { this.tolerance = tolerance; }
+        }
+        /**
+         * Points to transform
+         * @default undefined
+         */
+        points?: Base.Point3[];
+        /**
+         * Check first and last point for duplicates
+         * @default false
+         */
+        checkLastWithFirst? = false;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance? = 1e-7;
+    }
     export class RemoveConsecutiveDuplicatesDto {
         constructor(points?: Base.Point3[], tolerance?: number, checkFirstAndLast?: boolean) {
             if (points !== undefined) { this.points = points; }
@@ -579,8 +635,8 @@ export namespace Point {
         constructor(wdith?: number, height?: number, nrHexagonsU?: number, nrHexagonsV?: number, centerGrid?: boolean, pointsOnGround?: boolean) {
             if (wdith !== undefined) { this.width = wdith; }
             if (height !== undefined) { this.height = height; }
-            if (nrHexagonsU !== undefined) { this.nrHexagonsU = nrHexagonsU; }
-            if (nrHexagonsV !== undefined) { this.nrHexagonsV = nrHexagonsV; }
+            if (nrHexagonsU !== undefined) { this.nrHexagonsInHeight = nrHexagonsU; }
+            if (nrHexagonsV !== undefined) { this.nrHexagonsInWidth = nrHexagonsV; }
             if (centerGrid !== undefined) { this.centerGrid = centerGrid; }
             if (pointsOnGround !== undefined) { this.pointsOnGround = pointsOnGround; }
         }
@@ -598,20 +654,20 @@ export namespace Point {
          * @step 0.1
         */
         height? = 10;
-        /** Number of hexagons desired horizontally (U direction).
+        /** Number of hexagons desired in width.
          * @default 10
          * @minimum 0
          * @maximum Infinity
          * @step 1
          */
-        nrHexagonsU? = 10;
-        /** Number of hexagons desired vertically (V direction).
+        nrHexagonsInWidth? = 10;
+        /** Number of hexagons desired in height.
          * @default 10
          * @minimum 0
          * @maximum Infinity
          * @step 1
          */
-        nrHexagonsV? = 10;
+        nrHexagonsInHeight? = 10;
         /** If true, shift the entire grid up by half hex height. 
          * @default false
         */

packages/dev/base/lib/api/models/point/hex-grid-data.ts

@@ -1,6 +1,9 @@
 import { Base } from "../../inputs/base-inputs";
 
 export class HexGridData {
-    points: Base.Point3[];
+    centers: Base.Point3[];
     hexagons: Base.Point3[][];
+    shortestDistEdge: number;
+    longestDistEdge: number;
+    maxFilletRadius: number;
 }

packages/dev/base/lib/api/services/point.test.ts

@@ -668,7 +668,184 @@ describe("Point unit tests", () => {
             const result = point.sortPoints(input);
             expect(result).toEqual(expected);
         });
+    });
+
+    describe("calculateMaxFilletRadius", () => {
+        const defaultTolerance = 1e-7; // Default tolerance for the function if not provided
+        const precision = 6;           // Decimal places for toBeCloseTo assertions
+
+        // Helper to create input object matching the confusing naming convention
+        const createInput = (p1: Inputs.Base.Point3, corner: Inputs.Base.Point3, p2: Inputs.Base.Point3, tolerance: number = defaultTolerance): Inputs.Point.ThreePointsToleranceDto => ({
+            start: p1,
+            center: p2,
+            end: corner,
+            tolerance: tolerance
+        });
+
+        it("should calculate correct radius for a simple 90-degree corner (2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 3, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(3.0, precision);
+        });
+
+        it("should calculate correct radius for a symmetric 90-degree corner (2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [4, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 4, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(4.0, precision);
+        });
+
+        it("should calculate correct radius for an acute angle (60 degrees, 2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [5 * Math.cos(Math.PI / 3), 5 * Math.sin(Math.PI / 3), 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            const expected = 5 * Math.tan(Math.PI / 6);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(expected, precision);
+        });
+
+        it("should calculate correct radius for an obtuse angle (120 degrees, 2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [4, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [6 * Math.cos(2 * Math.PI / 3), 6 * Math.sin(2 * Math.PI / 3), 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            const expected = 4 * Math.tan(Math.PI / 3);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(expected, precision);
+        });
+
+        it("should return 0 for collinear points (0 degrees)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [10, 0, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should return 0 for collinear points (180 degrees)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [-3, 0, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should return 0 if one segment has near-zero length (P1=C)", () => {
+            const geoP1: Inputs.Base.Point3 = [defaultTolerance / 2, 0, 0]; // Very close to C
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 3, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should return 0 if one segment has near-zero length (P2=C)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, defaultTolerance / 3, 0]; // Very close to C
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should use the provided tolerance if specified", () => {
+            const customTolerance = 1e-4;
+            const geoP1: Inputs.Base.Point3 = [customTolerance / 2, 0, 0]; // Near zero relative to custom tolerance
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 3, 0];
+            const input = createInput(geoP1, geoC, geoP2, customTolerance);
+            // Expect 0 because len1 < customTolerance
+            expect(point.maxFilletRadius(input)).toBeCloseTo(0, precision);
+
+            const geoP1_ok: Inputs.Base.Point3 = [customTolerance * 2, 0, 0]; // OK relative to custom tolerance
+            const input_ok = createInput(geoP1_ok, geoC, geoP2, customTolerance);
+            // Expect non-zero result here
+            expect(point.maxFilletRadius(input_ok)).toBeGreaterThan(0);
+        });
+
+        it("should return 0 if all points coincide", () => {
+            const geoP1: Inputs.Base.Point3 = [0, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 0, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should calculate correct radius for a corner in 3D space", () => {
+            const geoP1: Inputs.Base.Point3 = [1, 1, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 2, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            const expected = Math.sqrt(2) * Math.tan(Math.PI / 8);
+            expect(point.maxFilletRadius(input)).toBeCloseTo(expected, precision);
+        });
+    });
+
+    describe("calculateMaxFilletRadiusHalfLine", () => {
+        const defaultTolerance = 1e-7;
+        const precision = 6;
 
+        const createInput = (p1: Inputs.Base.Point3, corner: Inputs.Base.Point3, p2: Inputs.Base.Point3, tolerance: number = defaultTolerance): Inputs.Point.ThreePointsToleranceDto => ({
+            start: p1, center: p2, end: corner, tolerance: tolerance
+        });
+
+        it("should calculate correct radius for a simple 90-degree corner (2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 3, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(1.5, precision);
+        });
+
+        it("should calculate correct radius for a symmetric 90-degree corner (2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [4, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 4, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(2.0, precision);
+        });
 
+        it("should calculate correct radius for an acute angle (60 degrees, 2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [6, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [4 * Math.cos(Math.PI / 3), 4 * Math.sin(Math.PI / 3), 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            const expected = 2 * Math.tan(Math.PI / 6);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(expected, precision);
+        });
+
+        it("should calculate correct radius for an obtuse angle (120 degrees, 2D)", () => {
+            const geoP1: Inputs.Base.Point3 = [4, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [6 * Math.cos(2 * Math.PI / 3), 6 * Math.sin(2 * Math.PI / 3), 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            const expected = 2 * Math.tan(Math.PI / 3);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(expected, precision);
+        });
+
+        it("should return 0 for collinear points (0 degrees)", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [10, 0, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should return 0 if one segment has near-zero length", () => {
+            const geoP1: Inputs.Base.Point3 = [5, 0, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, defaultTolerance / 3, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(0, precision);
+        });
+
+        it("should calculate correct radius for a corner in 3D space", () => {
+            const geoP1: Inputs.Base.Point3 = [1, 1, 0];
+            const geoC: Inputs.Base.Point3 = [0, 0, 0];
+            const geoP2: Inputs.Base.Point3 = [0, 2, 0];
+            const input = createInput(geoP1, geoC, geoP2);
+            const expected = (Math.sqrt(2) / 2.0) * Math.tan(Math.PI / 8);
+            expect(point.maxFilletRadiusHalfLine(input)).toBeCloseTo(expected, precision);
+        });
     });
 });