@bitbybit-dev/base 0.20.2 → 0.20.3

package/lib/api/services/point.d.ts

@@ -2,6 +2,8 @@ import { GeometryHelper } from "./geometry-helper";
 import * as Inputs from "../inputs";
 import { Transforms } from "./transforms";
 import { Vector } from "./vector";
+import * as Models from "../models";
+import { Lists } from "./lists";
 /**
  * Contains various methods for points. Point in bitbybit is simply an array containing 3 numbers for [x, y, z].
  * Because of this form Point can be interchanged with Vector, which also is an array in [x, y, z] form.
@@ -11,7 +13,8 @@ export declare class Point {
     private readonly geometryHelper;
     private readonly transforms;
     private readonly vector;
-    constructor(geometryHelper: GeometryHelper, transforms: Transforms, vector: Vector);
+    private readonly lists;
+    constructor(geometryHelper: GeometryHelper, transforms: Transforms, vector: Vector, lists: Lists);
     /**
      * Transforms the single point
      * @param inputs Contains a point and the transformations to apply
@@ -75,6 +78,15 @@ export declare class Point {
      * @drawable true
      */
     scalePointsCenterXYZ(inputs: Inputs.Point.ScalePointsCenterXYZDto): Inputs.Base.Point3[];
+    /**
+     * Stretch multiple points by providing center point, direction and uniform scale factor
+     * @param inputs Contains points, center point, direction and scale factor
+     * @returns Stretched points
+     * @group transforms
+     * @shortname stretch points dir from center
+     * @drawable true
+     */
+    stretchPointsDirFromCenter(inputs: Inputs.Point.StretchPointsDirFromCenterDto): Inputs.Base.Point3[];
     /**
      * Rotate multiple points by providing center point, axis and degrees of rotation
      * @param inputs Contains points, axis, center point and angle of rotation
@@ -220,6 +232,64 @@ export declare class Point {
      * @drawable true
      */
     hexGrid(inputs: Inputs.Point.HexGridCentersDto): Inputs.Base.Point3[];
+    /**
+     * Creates a pointy-top or flat-top hexagon grid, scaling hexagons to fit specified dimensions exactly.
+     * Returns both center points and the vertices of each (potentially scaled) hexagon.
+     * Hexagons are ordered column-first, then row-first.
+     * @param inputs Information about the desired grid dimensions and hexagon counts.
+     * @returns An object containing the array of center points and an array of hexagon vertex arrays.
+     * @group create
+     * @shortname scaled hex grid to fit
+     * @drawable false
+     */
+    hexGridScaledToFit(inputs: Inputs.Point.HexGridScaledToFitDto): Models.Point.HexGridData;
+    /**
+     * Calculates the maximum possible fillet radius at a corner formed by two line segments
+     * sharing an endpoint (C), such that the fillet arc is tangent to both segments
+     * and lies entirely within them.
+     * @param inputs three points and the tolerance
+     * @returns the maximum fillet radius
+     * @group fillet
+     * @shortname max fillet radius
+     * @drawable false
+     */
+    maxFilletRadius(inputs: Inputs.Point.ThreePointsToleranceDto): number;
+    /**
+     * Calculates the maximum possible fillet radius at a corner C, such that the fillet arc
+     * is tangent to both segments (P1-C, P2-C) and the tangent points lie within
+     * the first half of each segment (measured from C).
+     * @param inputs three points and the tolerance
+     * @returns the maximum fillet radius
+     * @group fillet
+     * @shortname max fillet radius half line
+     * @drawable false
+     */
+    maxFilletRadiusHalfLine(inputs: Inputs.Point.ThreePointsToleranceDto): number;
+    /**
+     * Calculates the maximum possible fillet radius at each corner of a polyline formed by
+     * formed by a series of points. The fillet radius is calculated for each internal
+     * corner and optionally for the closing corners if the polyline is closed.
+     * @param inputs Points, checkLastWithFirst flag, and tolerance
+     * @returns Array of maximum fillet radii for each corner
+     * @group fillet
+     * @shortname max fillets half line
+     * @drawable false
+     */
+    maxFilletsHalfLine(inputs: Inputs.Point.PointsMaxFilletsHalfLineDto): number[];
+    /**
+     * Calculates the single safest maximum fillet radius that can be applied
+     * uniformly to all corners of collection of points, based on the 'half-line' constraint.
+     * This is determined by finding the minimum of the maximum possible fillet
+     * radii calculated for each individual corner.
+     * @param inputs Defines the points, whether it's closed, and an optional tolerance.
+     * @returns The smallest value from the results of pointsMaxFilletsHalfLine.
+     *          Returns 0 if the polyline has fewer than 3 points or if any
+     *          calculated maximum radius is 0.
+     * @group fillet
+     * @shortname safest fillet radii points
+     * @drawable false
+     */
+    safestPointsMaxFilletHalfLine(inputs: Inputs.Point.PointsMaxFilletsHalfLineDto): number;
     /**
      * Removes consecutive duplicates from the point array with tolerance
      * @param inputs points, tolerance and check first and last
@@ -239,4 +309,29 @@ export declare class Point {
      */
     normalFromThreePoints(inputs: Inputs.Point.ThreePointsNormalDto): Inputs.Base.Vector3;
     private closestPointFromPointData;
+    /**
+     * Checks if two points are almost equal
+     * @param inputs Two points and the tolerance
+     * @returns true if the points are almost equal
+     * @group measure
+     * @shortname two points almost equal
+     * @drawable false
+     */
+    twoPointsAlmostEqual(inputs: Inputs.Point.TwoPointsToleranceDto): boolean;
+    /**
+     * Sorts points lexicographically (X, then Y, then Z)
+     * @param inputs points
+     * @returns sorted points
+     * @group sort
+     * @shortname sort points
+     * @drawable true
+     */
+    sortPoints(inputs: Inputs.Point.PointsDto): Inputs.Base.Point3[];
+    /**
+     * Calculates the 6 vertices of a regular flat-top hexagon.
+     * @param center The center point [x, y, z].
+     * @param radius The radius (distance from center to vertex).
+     * @returns An array of 6 Point3 vertices in counter-clockwise order.
+     */
+    private getRegularHexagonVertices;
 }