@bitbybit-dev/base 0.19.0-alpha.0

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

@@ -0,0 +1,304 @@
+import { Math } from "./inputs";
+export var Vector;
+(function (Vector) {
+    class TwoVectorsDto {
+        constructor(first, second) {
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+        }
+    }
+    Vector.TwoVectorsDto = TwoVectorsDto;
+    class VectorBoolDto {
+        constructor(vector) {
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.VectorBoolDto = VectorBoolDto;
+    class RemoveAllDuplicateVectorsDto {
+        constructor(vectors, tolerance) {
+            /**
+             * Tolerance value
+             * @default 1e-7
+             * @minimum 0
+             * @maximum Infinity
+             */
+            this.tolerance = 1e-7;
+            if (vectors !== undefined) {
+                this.vectors = vectors;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Vector.RemoveAllDuplicateVectorsDto = RemoveAllDuplicateVectorsDto;
+    class RemoveConsecutiveDuplicateVectorsDto {
+        constructor(vectors, checkFirstAndLast, tolerance) {
+            /**
+             * Check first and last vectors
+             * @default false
+             */
+            this.checkFirstAndLast = false;
+            /**
+             * Tolerance value
+             * @default 1e-7
+             * @minimum 0
+             * @maximum Infinity
+             */
+            this.tolerance = 1e-7;
+            if (vectors !== undefined) {
+                this.vectors = vectors;
+            }
+            if (checkFirstAndLast !== undefined) {
+                this.checkFirstAndLast = checkFirstAndLast;
+            }
+            if (tolerance !== undefined) {
+                this.tolerance = tolerance;
+            }
+        }
+    }
+    Vector.RemoveConsecutiveDuplicateVectorsDto = RemoveConsecutiveDuplicateVectorsDto;
+    class VectorDto {
+        constructor(vector) {
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.VectorDto = VectorDto;
+    class RangeMaxDto {
+        constructor(max) {
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Vector.RangeMaxDto = RangeMaxDto;
+    class VectorXYZDto {
+        constructor(x, y, z) {
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+            if (z !== undefined) {
+                this.z = z;
+            }
+        }
+    }
+    Vector.VectorXYZDto = VectorXYZDto;
+    class VectorXYDto {
+        constructor(x, y) {
+            if (x !== undefined) {
+                this.x = x;
+            }
+            if (y !== undefined) {
+                this.y = y;
+            }
+        }
+    }
+    Vector.VectorXYDto = VectorXYDto;
+    class SpanDto {
+        constructor(step, min, max) {
+            /**
+             * Step of the span
+             * @default 0.1
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.step = 0.1;
+            /**
+            * Min value of the span
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.min = 0;
+            /**
+            * Max value of the span
+            * @default 1
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.max = 1;
+            if (step !== undefined) {
+                this.step = step;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Vector.SpanDto = SpanDto;
+    class SpanEaseItemsDto {
+        constructor(nrItems, min, max, ease) {
+            /**
+             * Nr of items in the span
+             * @default 100
+             * @minimum 2
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrItems = 100;
+            /**
+            * Min value of the span
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.min = 0;
+            /**
+            * Max value of the span
+            * @default 1
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.max = 1;
+            /**
+            * Ease type
+            * @default easeInSine
+            */
+            this.ease = Math.easeEnum.easeInSine;
+            /**
+             * Indicates wether only intervals should be outputed. This will output step lengths between the values.
+             * @default false
+             */
+            this.intervals = false;
+            if (nrItems !== undefined) {
+                this.nrItems = nrItems;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+            if (ease !== undefined) {
+                this.ease = ease;
+            }
+        }
+    }
+    Vector.SpanEaseItemsDto = SpanEaseItemsDto;
+    class SpanLinearItemsDto {
+        constructor(nrItems, min, max) {
+            /**
+             * Nr of items in the span
+             * @default 100
+             * @minimum 2
+             * @maximum Infinity
+             * @step 1
+             */
+            this.nrItems = 100;
+            /**
+            * Min value of the span
+            * @default 0
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.min = 0;
+            /**
+            * Max value of the span
+            * @default 1
+            * @minimum -Infinity
+            * @maximum Infinity
+            * @step 1
+            */
+            this.max = 1;
+            if (nrItems !== undefined) {
+                this.nrItems = nrItems;
+            }
+            if (min !== undefined) {
+                this.min = min;
+            }
+            if (max !== undefined) {
+                this.max = max;
+            }
+        }
+    }
+    Vector.SpanLinearItemsDto = SpanLinearItemsDto;
+    class RayPointDto {
+        constructor(point, distance, vector) {
+            if (point !== undefined) {
+                this.point = point;
+            }
+            if (distance !== undefined) {
+                this.distance = distance;
+            }
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.RayPointDto = RayPointDto;
+    class VectorsDto {
+        constructor(vectors) {
+            if (vectors !== undefined) {
+                this.vectors = vectors;
+            }
+        }
+    }
+    Vector.VectorsDto = VectorsDto;
+    class FractionTwoVectorsDto {
+        constructor(fraction, first, second) {
+            /**
+             * Fraction number
+             * @default 0.5
+             * @minimum -Infinity
+             * @maximum Infinity
+             * @step 0.1
+             */
+            this.fraction = 0.5;
+            if (fraction !== undefined) {
+                this.fraction = fraction;
+            }
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+        }
+    }
+    Vector.FractionTwoVectorsDto = FractionTwoVectorsDto;
+    class VectorScalarDto {
+        constructor(scalar, vector) {
+            if (scalar !== undefined) {
+                this.scalar = scalar;
+            }
+            if (vector !== undefined) {
+                this.vector = vector;
+            }
+        }
+    }
+    Vector.VectorScalarDto = VectorScalarDto;
+    class TwoVectorsReferenceDto {
+        constructor(reference, first, second) {
+            if (reference !== undefined) {
+                this.reference = reference;
+            }
+            if (first !== undefined) {
+                this.first = first;
+            }
+            if (second !== undefined) {
+                this.second = second;
+            }
+        }
+    }
+    Vector.TwoVectorsReferenceDto = TwoVectorsReferenceDto;
+})(Vector || (Vector = {}));

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

@@ -0,0 +1,114 @@
+import * as Inputs from "../inputs/inputs";
+import { MathBitByBit } from "./math";
+export declare class Color {
+    private readonly math;
+    constructor(math: MathBitByBit);
+    /**
+     * Creates a hex color
+     * @param inputs Color hex
+     * @returns color string
+     * @group create
+     * @shortname color
+     * @drawable false
+     */
+    hexColor(inputs: Inputs.Color.HexDto): Inputs.Base.Color;
+    /**
+     * Creates rgb color from hex
+     * @param inputs Color hex
+     * @returns rgb color
+     * @group convert
+     * @shortname hex to rgb
+     * @drawable false
+     */
+    hexToRgb(inputs: Inputs.Color.HexDto): Inputs.Base.ColorRGB;
+    /**
+     * Creates hex color from rgb
+     * @param inputs Color hext
+     * @returns hex color
+     * @group convert
+     * @shortname rgb to hex
+     * @drawable false
+     */
+    rgbToHex(inputs: Inputs.Color.RGBMinMaxDto): Inputs.Base.Color;
+    /**
+     * Creates hex color from rgb obj that contains {r, g, b} properties in certain range
+     * @param inputs Color hext
+     * @returns hex color string
+     * @group convert
+     * @shortname rgb obj to hex
+     * @drawable false
+     */
+    rgbObjToHex(inputs: Inputs.Color.RGBObjectMaxDto): Inputs.Base.Color;
+    /**
+     * Creates rgb color from hex and maps to different range if needed
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group convert
+     * @shortname hex to rgb mapped
+     * @drawable false
+     */
+    hexToRgbMapped(inputs: Inputs.Color.HexDtoMapped): Inputs.Base.ColorRGB;
+    /**
+     * Get red param
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group hex to
+     * @shortname red
+     * @drawable false
+     */
+    getRedParam(inputs: Inputs.Color.HexDtoMapped): number;
+    /**
+     * Get green param
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group hex to
+     * @shortname green
+     * @drawable false
+     */
+    getGreenParam(inputs: Inputs.Color.HexDtoMapped): number;
+    /**
+     * Get blue param
+     * @param inputs Color hext
+     * @returns blue param
+     * @group hex to
+     * @shortname blue
+     * @drawable false
+     */
+    getBlueParam(inputs: Inputs.Color.HexDtoMapped): number;
+    /**
+     * RGB to red
+     * @param inputs Color rgb
+     * @returns red param
+     * @group  rgb to
+     * @shortname red
+     * @drawable false
+     */
+    rgbToRed(inputs: Inputs.Color.RGBObjectDto): number;
+    /**
+     * RGB to green
+     * @param inputs Color rgb
+     * @returns green param
+     * @group rgb to
+     * @shortname green
+     * @drawable false
+     */
+    rgbToGreen(inputs: Inputs.Color.RGBObjectDto): number;
+    /**
+     * RGB to blue
+     * @param inputs Color rgb
+     * @returns blue param
+     * @group rgb to
+     * @shortname blue
+     * @drawable false
+     */
+    rgbToBlue(inputs: Inputs.Color.RGBObjectDto): number;
+    /**
+     * Invert color
+     * @param inputs hex color and black and white option
+     * @returns inverted color
+     * @group hex to
+     * @shortname invert color
+     * @drawable false
+     */
+    invert(inputs: Inputs.Color.InvertHexDto): Inputs.Base.Color;
+}

package/lib/api/services/color.js

@@ -0,0 +1,170 @@
+export class Color {
+    constructor(math) {
+        this.math = math;
+    }
+    /**
+     * Creates a hex color
+     * @param inputs Color hex
+     * @returns color string
+     * @group create
+     * @shortname color
+     * @drawable false
+     */
+    hexColor(inputs) {
+        return inputs.color;
+    }
+    /**
+     * Creates rgb color from hex
+     * @param inputs Color hex
+     * @returns rgb color
+     * @group convert
+     * @shortname hex to rgb
+     * @drawable false
+     */
+    hexToRgb(inputs) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(inputs.color);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : undefined;
+    }
+    /**
+     * Creates hex color from rgb
+     * @param inputs Color hext
+     * @returns hex color
+     * @group convert
+     * @shortname rgb to hex
+     * @drawable false
+     */
+    rgbToHex(inputs) {
+        let r = inputs.r;
+        let g = inputs.g;
+        let b = inputs.b;
+        // sometimes rgb values are in 0 - 100 or 0 - 1 ranges
+        // so we need to remap them to 0 - 255
+        if (inputs.max !== 255) {
+            r = Math.round(this.math.remap({ number: r, fromLow: inputs.min, fromHigh: inputs.max, toLow: 0, toHigh: 255 }));
+            g = Math.round(this.math.remap({ number: g, fromLow: inputs.min, fromHigh: inputs.max, toLow: 0, toHigh: 255 }));
+            b = Math.round(this.math.remap({ number: b, fromLow: inputs.min, fromHigh: inputs.max, toLow: 0, toHigh: 255 }));
+        }
+        const s = `#${Number(0x1000000 + r * 0x10000 + g * 0x100 + b).toString(16).substring(1, 7)}`;
+        return s;
+    }
+    /**
+     * Creates hex color from rgb obj that contains {r, g, b} properties in certain range
+     * @param inputs Color hext
+     * @returns hex color string
+     * @group convert
+     * @shortname rgb obj to hex
+     * @drawable false
+     */
+    rgbObjToHex(inputs) {
+        return this.rgbToHex({ r: inputs.rgb.r, g: inputs.rgb.g, b: inputs.rgb.b, min: inputs.min, max: inputs.max });
+    }
+    /**
+     * Creates rgb color from hex and maps to different range if needed
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group convert
+     * @shortname hex to rgb mapped
+     * @drawable false
+     */
+    hexToRgbMapped(inputs) {
+        const rgb = this.hexToRgb(inputs);
+        return {
+            r: this.math.remap({ number: rgb.r, fromLow: 0, fromHigh: 255, toLow: inputs.from, toHigh: inputs.to }),
+            g: this.math.remap({ number: rgb.g, fromLow: 0, fromHigh: 255, toLow: inputs.from, toHigh: inputs.to }),
+            b: this.math.remap({ number: rgb.b, fromLow: 0, fromHigh: 255, toLow: inputs.from, toHigh: inputs.to }),
+        };
+    }
+    /**
+     * Get red param
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group hex to
+     * @shortname red
+     * @drawable false
+     */
+    getRedParam(inputs) {
+        const rgb = this.hexToRgbMapped(inputs);
+        return rgb.r;
+    }
+    /**
+     * Get green param
+     * @param inputs Color hext
+     * @returns rgb color
+     * @group hex to
+     * @shortname green
+     * @drawable false
+     */
+    getGreenParam(inputs) {
+        const rgb = this.hexToRgbMapped(inputs);
+        return rgb.g;
+    }
+    /**
+     * Get blue param
+     * @param inputs Color hext
+     * @returns blue param
+     * @group hex to
+     * @shortname blue
+     * @drawable false
+     */
+    getBlueParam(inputs) {
+        const rgb = this.hexToRgbMapped(inputs);
+        return rgb.b;
+    }
+    /**
+     * RGB to red
+     * @param inputs Color rgb
+     * @returns red param
+     * @group  rgb to
+     * @shortname red
+     * @drawable false
+     */
+    rgbToRed(inputs) {
+        return inputs.rgb.r;
+    }
+    /**
+     * RGB to green
+     * @param inputs Color rgb
+     * @returns green param
+     * @group rgb to
+     * @shortname green
+     * @drawable false
+     */
+    rgbToGreen(inputs) {
+        return inputs.rgb.g;
+    }
+    /**
+     * RGB to blue
+     * @param inputs Color rgb
+     * @returns blue param
+     * @group rgb to
+     * @shortname blue
+     * @drawable false
+     */
+    rgbToBlue(inputs) {
+        return inputs.rgb.b;
+    }
+    /**
+     * Invert color
+     * @param inputs hex color and black and white option
+     * @returns inverted color
+     * @group hex to
+     * @shortname invert color
+     * @drawable false
+     */
+    invert(inputs) {
+        const { r, g, b } = this.hexToRgbMapped({ color: inputs.color, from: 0, to: 255 });
+        if (inputs.blackAndWhite) {
+            return (r * 0.299 + g * 0.587 + b * 0.114) > 186
+                ? "#000000"
+                : "#ffffff";
+        }
+        const rInv = (255 - r);
+        const gInv = (255 - g);
+        const bInv = (255 - b);
+        return this.rgbToHex({ r: rInv, g: gInv, b: bInv, min: 0, max: 255 });
+    }
+}

package/lib/api/services/geometry-helper.d.ts

@@ -0,0 +1,15 @@
+import * as Inputs from "../inputs/inputs";
+export declare class GeometryHelper {
+    transformControlPoints(transformation: number[][] | number[][][], transformedControlPoints: Inputs.Base.Point3[]): Inputs.Base.Point3[];
+    getFlatTransformations(transformation: number[][] | number[][][]): number[][];
+    getArrayDepth: (value: any) => number;
+    transformPointsByMatrixArray(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[];
+    transformPointsCoordinates(points: Inputs.Base.Point3[], transform: number[]): Inputs.Base.Point3[];
+    removeAllDuplicateVectors(vectors: number[][], tolerance?: number): number[][];
+    removeConsecutiveVectorDuplicates(vectors: number[][], checkFirstAndLast?: boolean, tolerance?: number): number[][];
+    vectorsTheSame(vec1: number[], vec2: number[], tolerance: number): boolean;
+    approxEq(num1: number, num2: number, tolerance: number): boolean;
+    removeConsecutivePointDuplicates(points: Inputs.Base.Point3[], checkFirstAndLast?: boolean, tolerance?: number): Inputs.Base.Point3[];
+    arePointsTheSame(pointA: Inputs.Base.Point3 | Inputs.Base.Point2, pointB: Inputs.Base.Point3 | Inputs.Base.Point2, tolerance: number): boolean;
+    private transformCoordinates;
+}