@bitbybit-dev/base 0.20.1 → 0.20.3

package/lib/api/inputs/point-inputs.d.ts

@@ -252,6 +252,32 @@ export declare namespace Point {
          */
         scaleXyz: Base.Vector3;
     }
+    class StretchPointsDirFromCenterDto {
+        constructor(points?: Base.Point3[], center?: Base.Point3, direction?: Base.Vector3, scale?: number);
+        /**
+         * Points to transform
+         * @default undefined
+         */
+        points?: Base.Point3[];
+        /**
+         * The center from which the scaling is applied
+         * @default [0, 0, 0]
+         */
+        center?: Base.Point3;
+        /**
+         * Stretch direction vector
+         * @default [0, 0, 1]
+         */
+        direction?: Base.Vector3;
+        /**
+         * The scale factor to apply along the direction vector. 1.0 means no change.
+         * @default 2
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 0.1
+         */
+        scale?: number;
+    }
     class RotatePointsCenterAxisDto {
         constructor(points?: Base.Point3[], angle?: number, axis?: Base.Vector3, center?: Base.Point3);
         /**
@@ -314,6 +340,53 @@ export declare namespace Point {
          */
         reverseNormal: boolean;
     }
+    class ThreePointsToleranceDto {
+        constructor(start?: Base.Point3, center?: Base.Point3, end?: Base.Point3, tolerance?: number);
+        /**
+         * 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: number;
+    }
+    class PointsMaxFilletsHalfLineDto {
+        constructor(points?: Base.Point3[], checkLastWithFirst?: boolean, tolerance?: number);
+        /**
+         * Points to transform
+         * @default undefined
+         */
+        points?: Base.Point3[];
+        /**
+         * Check first and last point for duplicates
+         * @default false
+         */
+        checkLastWithFirst?: boolean;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance?: number;
+    }
     class RemoveConsecutiveDuplicatesDto {
         constructor(points?: Base.Point3[], tolerance?: number, checkFirstAndLast?: boolean);
         /**
@@ -347,6 +420,27 @@ export declare namespace Point {
          */
         point: Base.Point3;
     }
+    class TwoPointsToleranceDto {
+        constructor(point1?: Base.Point3, point2?: Base.Point3, tolerance?: number);
+        /**
+         * First point to compare
+         * @default undefined
+         */
+        point1?: Base.Point3;
+        /**
+         * Second point to compare
+         * @default undefined
+         */
+        point2?: Base.Point3;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-7
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-7
+         */
+        tolerance?: number;
+    }
     class StartEndPointsDto {
         constructor(startPoint?: Base.Point3, endPoint?: Base.Point3);
         /**
@@ -429,6 +523,65 @@ export declare namespace Point {
          */
         factor: number;
     }
+    class HexGridScaledToFitDto {
+        constructor(wdith?: number, height?: number, nrHexagonsU?: number, nrHexagonsV?: number, centerGrid?: boolean, pointsOnGround?: boolean);
+        /** Total desired width for the grid area. The hexagon size will be derived from this and nrHexagonsU.
+         * @default 10
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        width?: number;
+        /** Total desired height for the grid area. Note: due to hexagon geometry, the actual grid height might differ slightly if maintaining regular hexagons based on width.
+         * @default 10
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+        */
+        height?: number;
+        /** Number of hexagons desired in width.
+         * @default 10
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        nrHexagonsInWidth?: number;
+        /** Number of hexagons desired in height.
+         * @default 10
+         * @minimum 0
+         * @maximum Infinity
+         * @step 1
+         */
+        nrHexagonsInHeight?: number;
+        /** If true, the hexagons will be oriented with their flat sides facing up and down.
+         * @default false
+         */
+        flatTop?: boolean;
+        /** If true, shift the entire grid up by half hex height.
+         * @default false
+        */
+        extendTop?: boolean;
+        /** If true, shift the entire grid down by half hex height.
+         * @default false
+        */
+        extendBottom?: boolean;
+        /** If true, shift the entire grid left by half hex width.
+         * @default false
+        */
+        extendLeft?: boolean;
+        /** If true, shift the entire grid right by half hex width.
+         * @default false
+        */
+        extendRight?: boolean;
+        /** If true, the grid center (based on totalWidth/totalHeight) will be at [0,0,0].
+         * @default false
+         */
+        centerGrid?: boolean;
+        /** If true, swaps Y and Z coordinates and sets Y to 0, placing points on the XZ ground plane.
+         * @default false
+         */
+        pointsOnGround?: boolean;
+    }
     class HexGridCentersDto {
         constructor(nrHexagonsX?: number, nrHexagonsY?: number, radiusHexagon?: number, orientOnCenter?: boolean, pointsOnGround?: boolean);
         /**

package/lib/api/inputs/point-inputs.js

@@ -296,6 +296,41 @@ export var Point;
         }
     }
     Point.ScalePointsCenterXYZDto = ScalePointsCenterXYZDto;
+    class StretchPointsDirFromCenterDto {
+        constructor(points, center, direction, scale) {
+            /**
+             * The center from which the scaling is applied
+             * @default [0, 0, 0]
+             */
+            this.center = [0, 0, 0];
+            /**
+             * Stretch direction vector
+             * @default [0, 0, 1]
+             */
+            this.direction = [0, 0, 1];
+            /**
+             * The scale factor to apply along the direction vector. 1.0 means no change.
+             * @default 2
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.scale = 2;
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+            if (direction !== undefined) {
+                this.direction = direction;
+            }
+            if (scale !== undefined) {
+                this.scale = scale;
+            }
+        }
+    }
+    Point.StretchPointsDirFromCenterDto = StretchPointsDirFromCenterDto;
     class RotatePointsCenterAxisDto {
         constructor(points, angle, axis, center) {
             /**
@@ -364,6 +399,58 @@ export var Point;
         }
     }
     Point.ThreePointsNormalDto = ThreePointsNormalDto;
+    class ThreePointsToleranceDto {
+        constructor(start, center, end, tolerance) {
+            /**
+             * Tolerance for the calculation
+             * @default 1e-7
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            if (start !== undefined) {
+                this.start = start;
+            }
+            if (center !== undefined) {
+                this.center = center;
+            }
+            if (end !== undefined) {
+                this.end = end;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Point.ThreePointsToleranceDto = ThreePointsToleranceDto;
+    class PointsMaxFilletsHalfLineDto {
+        constructor(points, checkLastWithFirst, tolerance) {
+            /**
+             * Check first and last point for duplicates
+             * @default false
+             */
+            this.checkLastWithFirst = false;
+            /**
+             * Tolerance for the calculation
+             * @default 1e-7
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            if (points !== undefined) {
+                this.points = points;
+            }
+            if (checkLastWithFirst !== undefined) {
+                this.checkLastWithFirst = checkLastWithFirst;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Point.PointsMaxFilletsHalfLineDto = PointsMaxFilletsHalfLineDto;
     class RemoveConsecutiveDuplicatesDto {
         constructor(points, tolerance, checkFirstAndLast) {
             /**
@@ -401,6 +488,28 @@ export var Point;
         }
     }
     Point.ClosestPointFromPointsDto = ClosestPointFromPointsDto;
+    class TwoPointsToleranceDto {
+        constructor(point1, point2, tolerance) {
+            /**
+             * Tolerance for the calculation
+             * @default 1e-7
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 1e-7
+             */
+            this.tolerance = 1e-7;
+            if (point1 !== undefined) {
+                this.point1 = point1;
+            }
+            if (point2 !== undefined) {
+                this.point2 = point2;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Point.TwoPointsToleranceDto = TwoPointsToleranceDto;
     class StartEndPointsDto {
         constructor(startPoint, endPoint) {
             if (startPoint !== undefined) {
@@ -494,6 +603,85 @@ export var Point;
         }
     }
     Point.SpiralDto = SpiralDto;
+    class HexGridScaledToFitDto {
+        constructor(wdith, height, nrHexagonsU, nrHexagonsV, centerGrid, pointsOnGround) {
+            /** Total desired width for the grid area. The hexagon size will be derived from this and nrHexagonsU.
+             * @default 10
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.width = 10;
+            /** Total desired height for the grid area. Note: due to hexagon geometry, the actual grid height might differ slightly if maintaining regular hexagons based on width.
+             * @default 10
+             * @minimum 0
+             * @maximum Infinity
+             * @step 0.1
+            */
+            this.height = 10;
+            /** Number of hexagons desired in width.
+             * @default 10
+             * @minimum 0
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrHexagonsInWidth = 10;
+            /** Number of hexagons desired in height.
+             * @default 10
+             * @minimum 0
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrHexagonsInHeight = 10;
+            /** If true, the hexagons will be oriented with their flat sides facing up and down.
+             * @default false
+             */
+            this.flatTop = false;
+            /** If true, shift the entire grid up by half hex height.
+             * @default false
+            */
+            this.extendTop = false;
+            /** If true, shift the entire grid down by half hex height.
+             * @default false
+            */
+            this.extendBottom = false;
+            /** If true, shift the entire grid left by half hex width.
+             * @default false
+            */
+            this.extendLeft = false;
+            /** If true, shift the entire grid right by half hex width.
+             * @default false
+            */
+            this.extendRight = false;
+            /** If true, the grid center (based on totalWidth/totalHeight) will be at [0,0,0].
+             * @default false
+             */
+            this.centerGrid = false;
+            /** If true, swaps Y and Z coordinates and sets Y to 0, placing points on the XZ ground plane.
+             * @default false
+             */
+            this.pointsOnGround = false;
+            if (wdith !== undefined) {
+                this.width = wdith;
+            }
+            if (height !== undefined) {
+                this.height = height;
+            }
+            if (nrHexagonsU !== undefined) {
+                this.nrHexagonsInHeight = nrHexagonsU;
+            }
+            if (nrHexagonsV !== undefined) {
+                this.nrHexagonsInWidth = nrHexagonsV;
+            }
+            if (centerGrid !== undefined) {
+                this.centerGrid = centerGrid;
+            }
+            if (pointsOnGround !== undefined) {
+                this.pointsOnGround = pointsOnGround;
+            }
+        }
+    }
+    Point.HexGridScaledToFitDto = HexGridScaledToFitDto;
     class HexGridCentersDto {
         constructor(nrHexagonsX, nrHexagonsY, radiusHexagon, orientOnCenter, pointsOnGround) {
             /**

package/lib/api/inputs/polyline-inputs.d.ts

@@ -0,0 +1,206 @@
+import { Base } from "./base-inputs";
+export declare namespace Polyline {
+    class PolylineCreateDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(points?: Base.Point3[], isClosed?: boolean);
+        /**
+         * Points of the polyline
+         * @default undefined
+         */
+        points?: Base.Point3[];
+        /**
+         * Can contain is closed information
+         * @default false
+         */
+        isClosed?: boolean;
+    }
+    class PolylinePropertiesDto {
+        /**
+         * Provide options without default values
+         */
+        constructor(points?: Base.Point3[], isClosed?: boolean);
+        /**
+         * Points of the polyline
+         * @default undefined
+         */
+        points?: Base.Point3[];
+        /**
+         * Can contain is closed information
+         * @default false
+         */
+        isClosed?: boolean;
+        /**
+         * Optional polyline color
+         * @default #444444
+         */
+        color?: string | number[];
+    }
+    class PolylineDto {
+        constructor(polyline?: PolylinePropertiesDto);
+        /**
+         * Polyline with points
+         * @default undefined
+         */
+        polyline?: PolylinePropertiesDto;
+    }
+    class PolylinesDto {
+        constructor(polylines?: PolylinePropertiesDto[]);
+        /**
+         * Polylines array
+         * @default undefined
+         */
+        polylines?: PolylinePropertiesDto[];
+    }
+    class TransformPolylineDto {
+        constructor(polyline?: PolylinePropertiesDto, transformation?: Base.TransformMatrixes);
+        /**
+         * Polyline to transform
+         * @default undefined
+         */
+        polyline?: PolylinePropertiesDto;
+        /**
+         * Transformation matrix or a list of transformation matrixes
+         * @default undefined
+         */
+        transformation?: Base.TransformMatrixes;
+    }
+    class DrawPolylineDto<T> {
+        /**
+         * Provide options without default values
+         */
+        constructor(polyline?: PolylinePropertiesDto, opacity?: number, colours?: string | string[], size?: number, updatable?: boolean, polylineMesh?: T);
+        /**
+         * Polyline
+         * @default undefined
+         */
+        polyline?: PolylinePropertiesDto;
+        /**
+         * Value between 0 and 1
+         * @default 1
+         * @minimum 0
+         * @maximum 1
+         * @step 0.1
+         */
+        opacity?: number;
+        /**
+         * Hex colour string
+         * @default #444444
+         */
+        colours?: string | string[];
+        /**
+         * Width of the polyline
+         * @default 3
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        size?: number;
+        /**
+         * Indicates wether the position of this polyline will change in time
+         * @default false
+         */
+        updatable?: boolean;
+        /**
+         * Line mesh variable in case it already exists and needs updating
+         * @default undefined
+         */
+        polylineMesh?: T;
+    }
+    class DrawPolylinesDto<T> {
+        /**
+         * Provide options without default values
+         */
+        constructor(polylines?: PolylinePropertiesDto[], opacity?: number, colours?: string | string[], size?: number, updatable?: boolean, polylinesMesh?: T);
+        /**
+         * Polylines
+         * @default undefined
+         */
+        polylines?: PolylinePropertiesDto[];
+        /**
+         * Value between 0 and 1
+         * @default 1
+         * @minimum 0
+         * @maximum 1
+         * @step 0.1
+         */
+        opacity?: number;
+        /**
+         * Hex colour string
+         * @default #444444
+         */
+        colours?: string | string[];
+        /**
+         * Width of the polyline
+         * @default 3
+         * @minimum 0
+         * @maximum Infinity
+         * @step 0.1
+         */
+        size?: number;
+        /**
+         * Indicates wether the position of this polyline will change in time
+         * @default false
+         */
+        updatable?: boolean;
+        /**
+         * Polyline mesh variable in case it already exists and needs updating
+         * @default undefined
+         */
+        polylinesMesh?: T;
+    }
+    class SegmentsToleranceDto {
+        constructor(segments?: Base.Segment3[]);
+        /**
+         * Segments array
+         * @default undefined
+         */
+        segments?: Base.Segment3[];
+        /**
+         * Tolerance for the calculation
+         * @default 1e-5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-5
+         */
+        tolerance?: number;
+    }
+    class PolylineToleranceDto {
+        constructor(polyline?: PolylinePropertiesDto, tolerance?: number);
+        /**
+         * Polyline to check
+         * @default undefined
+         */
+        polyline?: PolylinePropertiesDto;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-5
+         */
+        tolerance?: number;
+    }
+    class TwoPolylinesToleranceDto {
+        constructor(polyline1?: PolylinePropertiesDto, polyline2?: PolylinePropertiesDto, tolerance?: number);
+        /**
+         * First polyline to check
+         * @default undefined
+         */
+        polyline1?: PolylinePropertiesDto;
+        /**
+         * Second polyline to check
+         * @default undefined
+         */
+        polyline2?: PolylinePropertiesDto;
+        /**
+         * Tolerance for the calculation
+         * @default 1e-5
+         * @minimum -Infinity
+         * @maximum Infinity
+         * @step 1e-5
+         */
+        tolerance?: number;
+    }
+}