@itwin/core-geometry 3.0.0-dev.76 → 3.0.0-dev.80

package/lib/esm/curve/spiral/CzechSpiralEvaluator.js

@@ -0,0 +1,198 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Curve
+ */
+import { Geometry } from "../../Geometry";
+import { CubicEvaluator } from "./CubicEvaluator";
+import { SimpleNewton } from "../../numerics/Newton";
+/**
+ * Czech cubic.
+ * This is y= m*x^3 with
+ * * x any point on the x axis
+ * * `fraction` along the spiral goes to `x = fraction * L`
+ * * m is gamma / (6RL)
+ *    * 1/(6RL) is the leading term of the sine series.
+ *    * `gamma = 2R/sqrt (4RR-LL)` pushes y down a little bit to simulate the lost series terms.
+ * @param localToWorld
+ * @param nominalL1
+ * @param nominalR1
+ * @param activeInterval
+ * @internal
+ */
+export class CzechSpiralEvaluator extends CubicEvaluator {
+    /** Constructor is private.  Caller responsible for cubicM validity. */
+    constructor(length1, radius1, cubicM) {
+        super(length1, cubicM);
+        this.nominalLength1 = length1;
+        this.nominalRadius1 = radius1;
+    }
+    /**
+     * Return the scale factor between simple x^3 / (6RL) cubic and the czech correction.
+     * * For typical case with l1/R1 smallish, this is just less than 1.0:
+     *   (0.25==>0.99215), (0.15==>0.997184), (0.10==>0.998749), (0.05==>999687)
+     * @param length1
+     * @param radius1
+     */
+    static gammaConstant(length1, radius1) {
+        return 2.0 * radius1 / Math.sqrt(4.0 * radius1 * radius1 - length1 * length1);
+    }
+    /** Compute the czech cubic constant. */
+    static computeCubicM(length1, radius1) {
+        const gamma = CzechSpiralEvaluator.gammaConstant(length1, radius1);
+        // In the private update method, the LR values should have been vetted.
+        if (gamma === undefined)
+            return undefined;
+        // If radius is negative, it shows up in gamma.  But the a signed denominator undoes it.  So take abs of denominator.
+        return gamma / Math.abs((6.0 * radius1 * length1));
+    }
+    static create(length1, radius1) {
+        const m = this.computeCubicM(length1, radius1);
+        if (m === undefined)
+            return undefined;
+        return new CzechSpiralEvaluator(length1, radius1, m);
+    }
+    scaleInPlace(scaleFactor) {
+        this.nominalLength1 *= scaleFactor;
+        this.nominalRadius1 *= scaleFactor;
+        super.scaleInPlace(scaleFactor);
+    }
+    /** return a deep copy of the evaluator */
+    clone() { return new CzechSpiralEvaluator(this.nominalLength1, this.nominalRadius1, this.cubicM); }
+    /** Member by member matchup ... */
+    isAlmostEqual(other) {
+        if (other instanceof CzechSpiralEvaluator) {
+            return Geometry.isSameCoordinate(this.nominalLength1, other.nominalLength1)
+                && Geometry.isSameCoordinate(this.nominalRadius1, other.nominalRadius1);
+        }
+        return false;
+    }
+    /**
+     * Return a (fast but mediocre) approximation of spiral length as a function of x axis position.
+     * * This x-to-distance relation is not as precise as the CurvePrimitive method moveSignedDistanceFromFraction.
+     * * It is supported here for users interested in replicating the Czech distance mapping rather than the more accurate CurvePrimitive measurements.
+     * @param x distance along the x axis.
+     */
+    xToCzechApproximateDistance(x) {
+        return CzechSpiralEvaluator.forwardL2R2Map(x, 1.0, this.nominalLength1, this.nominalRadius1);
+    }
+    /**
+     * Return the inverse of the `forwardL2R2Map` function.
+     * * The undefined result can only occur for distances outside the usual spirals.
+     * @param s (approximate) distance along the spiral.
+     *
+     */
+    czechApproximateDistanceToX(d) {
+        return CzechSpiralEvaluator.inverseL2R2Map(d, 1.0, this.nominalLength1, this.nominalRadius1);
+    }
+    /**
+       * evaluate a series expansion that is used with varying signs (plus or minus 1) in czech and italian spirals.
+       * @param x distance along the x axis.
+       */
+    static forwardL2R2Map(x, sign, length, radius) {
+        const l2 = length * length;
+        const r2 = radius * radius;
+        const Q = 4.0 * r2 - l2;
+        const xx = x * x;
+        return x * (1.0 + sign * xx * xx / (10.0 * Q * l2));
+    }
+    /**
+     * Return the inverse of the `forwardL2R2Map` function.
+     * * The undefined result can only occur for distances outside the usual spirals.
+     * @param s (approximate) distance along the spiral.
+     *
+     */
+    static inverseL2R2Map(b, sign, length, radius) {
+        const l2 = length * length;
+        const r2 = radius * radius;
+        const Q = 4.0 * r2 - l2;
+        const a = sign / (10.0 * Q * l2);
+        return SimpleNewton.runNewton1D(b, (x) => {
+            const xx = x * x;
+            return x * (1.0 + xx * xx * a) - b;
+        }, (x) => {
+            const xx = x * x;
+            return 1.0 + 5 * xx * xx * a;
+        });
+    }
+}
+/**
+ * Italian cubic.
+ * This is y= m*x^3 with
+ * * x any point on the x axis
+ * * `fraction` along the spiral goes to `x = fraction * L`
+ * * m is gamma / (6RL)
+ *    * 1/(6RL) is the leading term of the sine series.
+ *    * `gamma = 2R/sqrt (4RR-LL)` pushes y down a little bit to simulate the lost series terms.
+ * @param localToWorld
+ * @param nominalL1
+ * @param nominalR1
+ * @param activeInterval
+ * @internal
+ */
+export class ItalianSpiralEvaluator extends CubicEvaluator {
+    /** Constructor is private.  Caller responsible for cubicM validity. */
+    constructor(length1, radius1, lengthX, cubicM) {
+        super(lengthX, cubicM);
+        this.nominalLength1 = length1;
+        this.nominalRadius1 = radius1;
+    }
+    /** Compute the czech cubic constant.
+     * ** funky mixture of lengths ....
+     */
+    static computeCubicM(lengthXByForward, radius1) {
+        const gamma = CzechSpiralEvaluator.gammaConstant(lengthXByForward, radius1);
+        // In the private update method, the LR values should have been vetted.
+        if (gamma === undefined)
+            return undefined;
+        // If radius is negative, it shows up in gamma.  But the a signed denominator undoes it.  So take abs of denominator.
+        return gamma / Math.abs((6.0 * radius1 * lengthXByForward));
+    }
+    static create(length1, radius1) {
+        // um ... this seems goofy.  lengthX from forward, then invert for another .   But that's what the native code does ...
+        const lengthX = CzechSpiralEvaluator.forwardL2R2Map(length1, -1.0, length1, radius1);
+        const lengthX1 = CzechSpiralEvaluator.inverseL2R2Map(length1, 1.0, lengthX, radius1);
+        if (lengthX1 === undefined)
+            return undefined;
+        const m = ItalianSpiralEvaluator.computeCubicM(lengthX, radius1);
+        if (m === undefined)
+            return undefined;
+        return new ItalianSpiralEvaluator(length1, radius1, lengthX1, m);
+    }
+    scaleInPlace(scaleFactor) {
+        this.nominalLength1 *= scaleFactor;
+        this.nominalRadius1 *= scaleFactor;
+        super.scaleInPlace(scaleFactor);
+    }
+    /** return a deep copy of the evaluator */
+    clone() { return new ItalianSpiralEvaluator(this.nominalLength1, this.nominalRadius1, super.axisLength, this.cubicM); }
+    /** Member by member matchup ... */
+    isAlmostEqual(other) {
+        if (other instanceof ItalianSpiralEvaluator) {
+            return Geometry.isSameCoordinate(this.nominalLength1, other.nominalLength1)
+                && Geometry.isSameCoordinate(this.nominalRadius1, other.nominalRadius1);
+        }
+        return false;
+    }
+    /**
+       * Return a (fast but mediocre) approximation of spiral length as a function of x axis position.
+       * * This x-to-distance relation is not as precise as the CurvePrimitive method moveSignedDistanceFromFraction.
+       * * It is supported here for users interested in replicating the Czech distance mapping rather than the more accurate CurvePrimitive measurements.
+       * @param x distance along the x axis.
+       */
+    distanceToItalianApproximateX(x) {
+        return CzechSpiralEvaluator.forwardL2R2Map(x, -1.0, this.nominalLength1, this.nominalRadius1);
+    }
+    /**
+     * Return the inverse of the `forwardL2R2Map` function.
+     * * The undefined result can only occur for distances outside the usual spirals.
+     * @param s (approximate) distance along the spiral.
+     *
+     */
+    xToItalianApproximateDistance(d) {
+        return CzechSpiralEvaluator.inverseL2R2Map(d, -1.0, this.nominalLength1, this.nominalRadius1);
+    }
+}
+//# sourceMappingURL=CzechSpiralEvaluator.js.map

package/lib/esm/curve/spiral/CzechSpiralEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CzechSpiralEvaluator.js","sourceRoot":"","sources":["../../../../src/curve/spiral/CzechSpiralEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** @packageDocumentation\r\n * @module Curve\r\n */\r\nimport { Geometry } from \"../../Geometry\";\r\nimport { CubicEvaluator } from \"./CubicEvaluator\";\r\nimport { SimpleNewton } from \"../../numerics/Newton\";\r\n/**\r\n * Czech cubic.\r\n * This is y= m*x^3 with\r\n * * x any point on the x axis\r\n * * `fraction` along the spiral goes to `x = fraction * L`\r\n * * m is gamma / (6RL)\r\n *    * 1/(6RL) is the leading term of the sine series.\r\n *    * `gamma = 2R/sqrt (4RR-LL)` pushes y down a little bit to simulate the lost series terms.\r\n * @param localToWorld\r\n * @param nominalL1\r\n * @param nominalR1\r\n * @param activeInterval\r\n * @internal\r\n */\r\nexport class CzechSpiralEvaluator extends CubicEvaluator {\r\n  public nominalLength1: number;\r\n  public nominalRadius1: number;\r\n\r\n  /** Constructor is private.  Caller responsible for cubicM validity. */\r\n  private constructor(length1: number, radius1: number, cubicM: number) {\r\n    super(length1, cubicM);\r\n    this.nominalLength1 = length1;\r\n    this.nominalRadius1 = radius1;\r\n  }\r\n  /**\r\n   * Return the scale factor between simple x^3 / (6RL) cubic and the czech correction.\r\n   * * For typical case with l1/R1 smallish, this is just less than 1.0:\r\n   *   (0.25==>0.99215), (0.15==>0.997184), (0.10==>0.998749), (0.05==>999687)\r\n   * @param length1\r\n   * @param radius1\r\n   */\r\n  public static gammaConstant(length1: number, radius1: number): number | undefined {\r\n    return 2.0 * radius1 / Math.sqrt(4.0 * radius1 * radius1 - length1 * length1);\r\n  }\r\n  /** Compute the czech cubic constant. */\r\n  public static computeCubicM(length1: number, radius1: number): number | undefined {\r\n    const gamma = CzechSpiralEvaluator.gammaConstant(length1, radius1);\r\n    // In the private update method, the LR values should have been vetted.\r\n    if (gamma === undefined)\r\n      return undefined;\r\n    // If radius is negative, it shows up in gamma.  But the a signed denominator undoes it.  So take abs of denominator.\r\n    return gamma / Math.abs((6.0 * radius1 * length1));\r\n  }\r\n\r\n  public static create(length1: number, radius1: number): CzechSpiralEvaluator | undefined {\r\n    const m = this.computeCubicM(length1, radius1);\r\n    if (m === undefined)\r\n      return undefined;\r\n    return new CzechSpiralEvaluator(length1, radius1, m);\r\n  }\r\n\r\n  public override scaleInPlace(scaleFactor: number) {\r\n    this.nominalLength1 *= scaleFactor;\r\n    this.nominalRadius1 *= scaleFactor;\r\n    super.scaleInPlace(scaleFactor);\r\n  }\r\n  /** return a deep copy of the evaluator */\r\n  public clone(): CzechSpiralEvaluator { return new CzechSpiralEvaluator(this.nominalLength1, this.nominalRadius1, this.cubicM); }\r\n  /** Member by member matchup ... */\r\n  public isAlmostEqual(other: any): boolean {\r\n    if (other instanceof CzechSpiralEvaluator) {\r\n      return Geometry.isSameCoordinate(this.nominalLength1, other.nominalLength1)\r\n        && Geometry.isSameCoordinate(this.nominalRadius1, other.nominalRadius1);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Return a (fast but mediocre) approximation of spiral length as a function of x axis position.\r\n   * * This x-to-distance relation is not as precise as the CurvePrimitive method moveSignedDistanceFromFraction.\r\n   * * It is supported here for users interested in replicating the Czech distance mapping rather than the more accurate CurvePrimitive measurements.\r\n   * @param x distance along the x axis.\r\n   */\r\n  public xToCzechApproximateDistance(x: number): number {\r\n    return CzechSpiralEvaluator.forwardL2R2Map(x, 1.0, this.nominalLength1, this.nominalRadius1);\r\n  }\r\n  /**\r\n   * Return the inverse of the `forwardL2R2Map` function.\r\n   * * The undefined result can only occur for distances outside the usual spirals.\r\n   * @param s (approximate) distance along the spiral.\r\n   *\r\n   */\r\n  public czechApproximateDistanceToX(d: number): number | undefined {\r\n    return CzechSpiralEvaluator.inverseL2R2Map(d, 1.0, this.nominalLength1, this.nominalRadius1);\r\n  }\r\n\r\n  /**\r\n     * evaluate a series expansion that is used with varying signs (plus or minus 1) in czech and italian spirals.\r\n     * @param x distance along the x axis.\r\n     */\r\n  public static forwardL2R2Map(x: number, sign: number, length: number, radius: number): number {\r\n    const l2 = length * length;\r\n    const r2 = radius * radius;\r\n    const Q = 4.0 * r2 - l2;\r\n    const xx = x * x;\r\n    return x * (1.0 + sign * xx * xx / (10.0 * Q * l2));\r\n  }\r\n  /**\r\n   * Return the inverse of the `forwardL2R2Map` function.\r\n   * * The undefined result can only occur for distances outside the usual spirals.\r\n   * @param s (approximate) distance along the spiral.\r\n   *\r\n   */\r\n  public static inverseL2R2Map(b: number, sign: number, length: number, radius: number): number | undefined {\r\n    const l2 = length * length;\r\n    const r2 = radius * radius;\r\n    const Q = 4.0 * r2 - l2;\r\n    const a = sign / (10.0 * Q * l2);\r\n    return SimpleNewton.runNewton1D(b,\r\n      (x: number) => {\r\n        const xx = x * x;\r\n        return x * (1.0 + xx * xx * a) - b;\r\n      },\r\n      (x: number) => {\r\n        const xx = x * x;\r\n        return 1.0 + 5 * xx * xx * a;\r\n      });\r\n  }\r\n}\r\n/**\r\n * Italian cubic.\r\n * This is y= m*x^3 with\r\n * * x any point on the x axis\r\n * * `fraction` along the spiral goes to `x = fraction * L`\r\n * * m is gamma / (6RL)\r\n *    * 1/(6RL) is the leading term of the sine series.\r\n *    * `gamma = 2R/sqrt (4RR-LL)` pushes y down a little bit to simulate the lost series terms.\r\n * @param localToWorld\r\n * @param nominalL1\r\n * @param nominalR1\r\n * @param activeInterval\r\n * @internal\r\n */\r\nexport class ItalianSpiralEvaluator extends CubicEvaluator {\r\n  public nominalLength1: number;\r\n  public nominalRadius1: number;\r\n\r\n  /** Compute the czech cubic constant.\r\n   * ** funky mixture of lengths ....\r\n   */\r\n  private static computeCubicM(lengthXByForward: number, radius1: number): number | undefined {\r\n    const gamma = CzechSpiralEvaluator.gammaConstant(lengthXByForward, radius1);\r\n    // In the private update method, the LR values should have been vetted.\r\n    if (gamma === undefined)\r\n      return undefined;\r\n    // If radius is negative, it shows up in gamma.  But the a signed denominator undoes it.  So take abs of denominator.\r\n    return gamma / Math.abs((6.0 * radius1 * lengthXByForward));\r\n  }\r\n\r\n  /** Constructor is private.  Caller responsible for cubicM validity. */\r\n  private constructor(length1: number, radius1: number, lengthX: number, cubicM: number) {\r\n    super(lengthX, cubicM);\r\n    this.nominalLength1 = length1;\r\n    this.nominalRadius1 = radius1;\r\n  }\r\n  public static create(length1: number, radius1: number): ItalianSpiralEvaluator | undefined {\r\n    // um ... this seems goofy.  lengthX from forward, then invert for another .   But that's what the native code does ...\r\n    const lengthX = CzechSpiralEvaluator.forwardL2R2Map(length1, -1.0, length1, radius1);\r\n    const lengthX1 = CzechSpiralEvaluator.inverseL2R2Map(length1, 1.0, lengthX, radius1);\r\n    if (lengthX1 === undefined)\r\n      return undefined;\r\n    const m = ItalianSpiralEvaluator.computeCubicM(lengthX, radius1);\r\n    if (m === undefined)\r\n      return undefined;\r\n    return new ItalianSpiralEvaluator(length1, radius1, lengthX1, m);\r\n  }\r\n\r\n  public override scaleInPlace(scaleFactor: number) {\r\n    this.nominalLength1 *= scaleFactor;\r\n    this.nominalRadius1 *= scaleFactor;\r\n    super.scaleInPlace(scaleFactor);\r\n  }\r\n  /** return a deep copy of the evaluator */\r\n  public clone(): ItalianSpiralEvaluator { return new ItalianSpiralEvaluator(this.nominalLength1, this.nominalRadius1, super.axisLength, this.cubicM); }\r\n  /** Member by member matchup ... */\r\n  public isAlmostEqual(other: any): boolean {\r\n    if (other instanceof ItalianSpiralEvaluator) {\r\n      return Geometry.isSameCoordinate(this.nominalLength1, other.nominalLength1)\r\n        && Geometry.isSameCoordinate(this.nominalRadius1, other.nominalRadius1);\r\n    }\r\n    return false;\r\n  }\r\n  /**\r\n     * Return a (fast but mediocre) approximation of spiral length as a function of x axis position.\r\n     * * This x-to-distance relation is not as precise as the CurvePrimitive method moveSignedDistanceFromFraction.\r\n     * * It is supported here for users interested in replicating the Czech distance mapping rather than the more accurate CurvePrimitive measurements.\r\n     * @param x distance along the x axis.\r\n     */\r\n  public distanceToItalianApproximateX(x: number): number {\r\n    return CzechSpiralEvaluator.forwardL2R2Map(x, -1.0, this.nominalLength1, this.nominalRadius1);\r\n  }\r\n  /**\r\n   * Return the inverse of the `forwardL2R2Map` function.\r\n   * * The undefined result can only occur for distances outside the usual spirals.\r\n   * @param s (approximate) distance along the spiral.\r\n   *\r\n   */\r\n  public xToItalianApproximateDistance(d: number): number | undefined {\r\n    return CzechSpiralEvaluator.inverseL2R2Map(d, -1.0, this.nominalLength1, this.nominalRadius1);\r\n  }\r\n}\r\n"]}

package/lib/esm/curve/spiral/DirectHalfCosineSpiralEvaluator.d.ts

@@ -0,0 +1,39 @@
+import { XYCurveEvaluator } from "./XYCurveEvaluator";
+/**
+ * @internal
+ */
+export declare class DirectHalfCosineSpiralEvaluator extends XYCurveEvaluator {
+    nominalLength1: number;
+    nominalRadius1: number;
+    private _c;
+    private _c1;
+    private _c2;
+    constructor(length1: number, radius1: number);
+    private updateConstants;
+    scaleInPlace(scaleFactor: number): void;
+    /** return a deep copy of the evaluator */
+    clone(): DirectHalfCosineSpiralEvaluator;
+    /** Member by member matchup ... */
+    isAlmostEqual(other: any): boolean;
+    /** Evaluate X at fractional position. */
+    fractionToX(fraction: number): number;
+    /** Evaluate Y at fractional position. */
+    fractionToY(fraction: number): number;
+    /** Evaluate derivative of X with respect to fraction at fractional position. */
+    fractionToDX(_fraction: number): number;
+    /** Evaluate derivative of Y with respect to fraction at fractional position. */
+    fractionToDY(fraction: number): number;
+    /** Evaluate second derivative of X with respect to fraction at fractional position. */
+    fractionToDDX(_fraction: number): number;
+    /** Evaluate third derivative of Y with respect to fraction at fractional position. */
+    fractionToDDY(fraction: number): number;
+    /** Evaluate second derivative of X with respect to fraction at fractional position. */
+    fractionToD3X(_fraction: number): number;
+    /** Evaluate third derivative of Y with respect to fraction at fractional position. */
+    fractionToD3Y(fraction: number): number;
+    /** Return the magnitude of the first vector at fractional coordinate. */
+    fractionToTangentMagnitude(fraction: number): number;
+    /** Invert the fractionToX function for given X. */
+    xToFraction(x: number): number | undefined;
+}
+//# sourceMappingURL=DirectHalfCosineSpiralEvaluator.d.ts.map

package/lib/esm/curve/spiral/DirectHalfCosineSpiralEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DirectHalfCosineSpiralEvaluator.d.ts","sourceRoot":"","sources":["../../../../src/curve/spiral/DirectHalfCosineSpiralEvaluator.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,gBAAgB;IAC5D,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,GAAG,CAAS;gBACD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAWnD,OAAO,CAAC,eAAe;IAGhB,YAAY,CAAC,WAAW,EAAE,MAAM;IAKvC,0CAA0C;IACnC,KAAK,IAAI,+BAA+B;IAC/C,mCAAmC;IAC5B,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO;IAQzC,yCAAyC;IAClC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAC5C,yCAAyC;IAClC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAI5C,gFAAgF;IACzE,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAE9C,gFAAgF;IAEzE,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK7C,uFAAuF;IAChF,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAE/C,sFAAsF;IAE/E,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK9C,uFAAuF;IAChF,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAE/C,sFAAsF;IAE/E,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM9C,yEAAyE;IAEzD,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAIpE,mDAAmD;IAC5C,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAUlD"}

package/lib/esm/curve/spiral/DirectHalfCosineSpiralEvaluator.js

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Curve
+ */
+import { Geometry } from "../../Geometry";
+import { XYCurveEvaluator } from "./XYCurveEvaluator";
+import { SimpleNewton } from "../../numerics/Newton";
+/**
+ * @internal
+ */
+export class DirectHalfCosineSpiralEvaluator extends XYCurveEvaluator {
+    constructor(length1, radius1) {
+        super();
+        this.nominalLength1 = length1;
+        this.nominalRadius1 = radius1;
+        const pi = Math.PI;
+        this._c1 = 1.0 / (2.0 * pi * pi);
+        this._c2 = 0.25;
+        this._c = 0.0; // TO BE UPDATED BELOW
+        this.updateConstants();
+    }
+    updateConstants() {
+        this._c = this.nominalLength1 * this.nominalLength1 / this.nominalRadius1;
+    }
+    scaleInPlace(scaleFactor) {
+        this.nominalLength1 *= scaleFactor;
+        this.nominalRadius1 *= scaleFactor;
+        this.updateConstants();
+    }
+    /** return a deep copy of the evaluator */
+    clone() { return new DirectHalfCosineSpiralEvaluator(this.nominalLength1, this.nominalRadius1); }
+    /** Member by member matchup ... */
+    isAlmostEqual(other) {
+        if (other instanceof DirectHalfCosineSpiralEvaluator) {
+            return Geometry.isSameCoordinate(this.nominalLength1, other.nominalLength1)
+                && Geometry.isSameCoordinate(this.nominalRadius1, other.nominalRadius1);
+            // remark: c,c1,c2 are computed, need not be tested.
+        }
+        return false;
+    }
+    /** Evaluate X at fractional position. */
+    fractionToX(fraction) { return fraction * this.nominalLength1; }
+    /** Evaluate Y at fractional position. */
+    fractionToY(fraction) {
+        const theta = fraction * Math.PI;
+        return this._c * (this._c2 * fraction * fraction - this._c1 * (1.0 - Math.cos(theta)));
+    }
+    /** Evaluate derivative of X with respect to fraction at fractional position. */
+    fractionToDX(_fraction) { return this.nominalLength1; }
+    /** Evaluate derivative of Y with respect to fraction at fractional position. */
+    fractionToDY(fraction) {
+        const pi = Math.PI;
+        const theta = fraction * pi;
+        return this._c * (2.0 * this._c2 * fraction - this._c1 * pi * Math.sin(theta));
+    }
+    /** Evaluate second derivative of X with respect to fraction at fractional position. */
+    fractionToDDX(_fraction) { return 0.0; }
+    /** Evaluate third derivative of Y with respect to fraction at fractional position. */
+    fractionToDDY(fraction) {
+        const pi = Math.PI;
+        const theta = fraction * pi;
+        return this._c * (2.0 * this._c2 - this._c1 * pi * pi * Math.cos(theta));
+    }
+    /** Evaluate second derivative of X with respect to fraction at fractional position. */
+    fractionToD3X(_fraction) { return 0.0; }
+    /** Evaluate third derivative of Y with respect to fraction at fractional position. */
+    fractionToD3Y(fraction) {
+        const pi = Math.PI;
+        const theta = fraction * pi;
+        return this._c * this._c1 * pi * pi * pi * Math.sin(theta);
+    }
+    /** Return the magnitude of the first vector at fractional coordinate. */
+    fractionToTangentMagnitude(fraction) {
+        return Geometry.hypotenuseXY(this.fractionToDX(fraction), this.fractionToDY(fraction));
+    }
+    /** Invert the fractionToX function for given X. */
+    xToFraction(x) {
+        const fraction0 = x / this.nominalLength1;
+        const fraction1 = SimpleNewton.runNewton1D(fraction0, (f) => (this.fractionToX(f) - x), (f) => this.fractionToDX(f));
+        if (fraction1 === undefined)
+            return undefined;
+        return fraction1;
+    }
+}
+//# sourceMappingURL=DirectHalfCosineSpiralEvaluator.js.map

package/lib/esm/curve/spiral/DirectHalfCosineSpiralEvaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DirectHalfCosineSpiralEvaluator.js","sourceRoot":"","sources":["../../../../src/curve/spiral/DirectHalfCosineSpiralEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/*---------------------------------------------------------------------------------------------\r\n* Copyright (c) Bentley Systems, Incorporated. All rights reserved.\r\n* See LICENSE.md in the project root for license terms and full copyright notice.\r\n*--------------------------------------------------------------------------------------------*/\r\n\r\n/** @packageDocumentation\r\n * @module Curve\r\n */\r\nimport { Geometry } from \"../../Geometry\";\r\nimport { XYCurveEvaluator } from \"./XYCurveEvaluator\";\r\nimport { SimpleNewton } from \"../../numerics/Newton\";\r\n/**\r\n * @internal\r\n */\r\nexport class DirectHalfCosineSpiralEvaluator extends XYCurveEvaluator {\r\n  public nominalLength1: number;\r\n  public nominalRadius1: number;\r\n  private _c: number;\r\n  private _c1: number;\r\n  private _c2: number;\r\n  public constructor(length1: number, radius1: number) {\r\n    super();\r\n    this.nominalLength1 = length1;\r\n    this.nominalRadius1 = radius1;\r\n    const pi = Math.PI;\r\n    this._c1 = 1.0 / (2.0 * pi * pi);\r\n    this._c2 = 0.25;\r\n    this._c = 0.0; // TO BE UPDATED BELOW\r\n    this.updateConstants();\r\n  }\r\n\r\n  private updateConstants() {\r\n    this._c = this.nominalLength1 * this.nominalLength1 / this.nominalRadius1;\r\n  }\r\n  public scaleInPlace(scaleFactor: number) {\r\n    this.nominalLength1 *= scaleFactor;\r\n    this.nominalRadius1 *= scaleFactor;\r\n    this.updateConstants();\r\n  }\r\n  /** return a deep copy of the evaluator */\r\n  public clone(): DirectHalfCosineSpiralEvaluator { return new DirectHalfCosineSpiralEvaluator(this.nominalLength1, this.nominalRadius1); }\r\n  /** Member by member matchup ... */\r\n  public isAlmostEqual(other: any): boolean {\r\n    if (other instanceof DirectHalfCosineSpiralEvaluator) {\r\n      return Geometry.isSameCoordinate(this.nominalLength1, other.nominalLength1)\r\n        && Geometry.isSameCoordinate(this.nominalRadius1, other.nominalRadius1);\r\n      // remark: c,c1,c2 are computed, need not be tested.\r\n    }\r\n    return false;\r\n  }\r\n  /** Evaluate X at fractional position. */\r\n  public fractionToX(fraction: number): number { return fraction * this.nominalLength1; }\r\n  /** Evaluate Y at fractional position. */\r\n  public fractionToY(fraction: number): number {\r\n    const theta = fraction * Math.PI;\r\n    return this._c * (this._c2 * fraction * fraction - this._c1 * (1.0 - Math.cos(theta)));\r\n  }\r\n  /** Evaluate derivative of X with respect to fraction at fractional position. */\r\n  public fractionToDX(_fraction: number): number { return this.nominalLength1; }\r\n\r\n  /** Evaluate derivative of Y with respect to fraction at fractional position. */\r\n\r\n  public fractionToDY(fraction: number): number {\r\n    const pi = Math.PI;\r\n    const theta = fraction * pi;\r\n    return this._c * (2.0 * this._c2 * fraction - this._c1 * pi * Math.sin(theta));\r\n  }\r\n  /** Evaluate second derivative of X with respect to fraction at fractional position. */\r\n  public fractionToDDX(_fraction: number): number { return 0.0; }\r\n\r\n  /** Evaluate third derivative of Y with respect to fraction at fractional position. */\r\n\r\n  public fractionToDDY(fraction: number): number {\r\n    const pi = Math.PI;\r\n    const theta = fraction * pi;\r\n    return this._c * (2.0 * this._c2 - this._c1 * pi * pi * Math.cos(theta));\r\n  }\r\n  /** Evaluate second derivative of X with respect to fraction at fractional position. */\r\n  public fractionToD3X(_fraction: number): number { return 0.0; }\r\n\r\n  /** Evaluate third derivative of Y with respect to fraction at fractional position. */\r\n\r\n  public fractionToD3Y(fraction: number): number {\r\n    const pi = Math.PI;\r\n    const theta = fraction * pi;\r\n    return this._c * this._c1 * pi * pi * pi * Math.sin(theta);\r\n  }\r\n\r\n  /** Return the magnitude of the first vector at fractional coordinate. */\r\n\r\n  public override fractionToTangentMagnitude(fraction: number): number {\r\n    return Geometry.hypotenuseXY(this.fractionToDX(fraction), this.fractionToDY(fraction));\r\n\r\n  }\r\n  /** Invert the fractionToX function for given X. */\r\n  public xToFraction(x: number): number | undefined {\r\n    const fraction0 = x / this.nominalLength1;\r\n    const fraction1 = SimpleNewton.runNewton1D(fraction0,\r\n      (f: number) => (this.fractionToX(f) - x),\r\n      (f: number) => this.fractionToDX(f));\r\n    if (fraction1 === undefined)\r\n      return undefined;\r\n    return fraction1;\r\n\r\n  }\r\n}\r\n"]}

package/lib/esm/curve/spiral/DirectSpiral3d.d.ts

@@ -0,0 +1,265 @@
+import { GeometryHandler, IStrokeHandler } from "../../geometry3d/GeometryHandler";
+import { Plane3dByOriginAndUnitNormal } from "../../geometry3d/Plane3dByOriginAndUnitNormal";
+import { Plane3dByOriginAndVectors } from "../../geometry3d/Plane3dByOriginAndVectors";
+import { Point3d } from "../../geometry3d/Point3dVector3d";
+import { Range3d } from "../../geometry3d/Range";
+import { Ray3d } from "../../geometry3d/Ray3d";
+import { Segment1d } from "../../geometry3d/Segment1d";
+import { Transform } from "../../geometry3d/Transform";
+import { LineString3d } from "../LineString3d";
+import { StrokeOptions } from "../StrokeOptions";
+import { TransitionConditionalProperties } from "./TransitionConditionalProperties";
+import { XYCurveEvaluator } from "./XYCurveEvaluator";
+import { TransitionSpiral3d } from "./TransitionSpiral3d";
+import { Angle } from "../../geometry3d/Angle";
+/**
+* DirectSpiral3d acts like a TransitionSpiral3d for serialization purposes, but implements spiral types that have "direct" xy calculations without the integrations required
+* for IntegratedSpiral3d.
+* * Each DirectSpiral3d carries an XYCurveEvaluator to give it specialized behavior.
+* * Direct spirals that flow through serialization to native imodel02 are create with these static methods:
+*   * createArema
+*   * createJapaneseCubic
+*   * createAustralianRail
+*   * createDirectHalfCosine
+*   * createChineseCubic
+*   * createCzechCubic
+*   * createPolishCubic
+*   * createItalian
+*   * createWesternAustralian
+* @public
+*/
+export declare class DirectSpiral3d extends TransitionSpiral3d {
+    /** String name for schema properties */
+    readonly curvePrimitiveType = "transitionSpiral";
+    /** stroked approximation of entire spiral. */
+    private _globalStrokes;
+    /** stroked approximation of active spiral.
+     * * Same count as global -- possibly overly fine, but it gives some consistency between same clothoid constructed as partial versus complete.
+     * * If no trimming, this points to the same place as the _globalStrokes !!!  Don't double transform!!!
+     */
+    private _activeStrokes?;
+    /** Return the internal stroked form of the (possibly partial) spiral   */
+    get activeStrokes(): LineString3d;
+    private _nominalL1;
+    private _nominalR1;
+    private _evaluator;
+    /** Return the nominal end radius. */
+    get nominalR1(): number;
+    /** Return the nominal distance from inflection to endpoint. */
+    get nominalL1(): number;
+    /** Return the nominal end curvature */
+    get nominalCurvature1(): number;
+    /** Return the low level evaluator
+     * @internal
+     */
+    get evaluator(): XYCurveEvaluator;
+    constructor(localToWorld: Transform, spiralType: string | undefined, originalProperties: TransitionConditionalProperties | undefined, nominalL1: number, nominalR1: number, activeFractionInterval: Segment1d | undefined, evaluator: XYCurveEvaluator);
+    /**
+     * Compute stroke data in an interval.
+     * @param strokes strokes to clear and refill.
+     * @param fraction0 start fraction
+     * @param fraction1 end fraction
+     */
+    private computeStrokes;
+    /** Recompute strokes */
+    refreshComputedProperties(): void;
+    /**
+     * Create a spiral object which uses numXTerm terms from the clothoid X series and numYTerm from the clothoid Y series.
+     * @param numXTerm  number of terms to use from X series
+     * @param numYTerm number of terms to use from Y series
+     * @param localToWorld placement frame.  Inflection point is at origin, initial direction is along x axis.
+     * @param nominalL1 design distance from inflection to end point.
+     * @param nominalR1 design radius at end point.
+     * @param activeInterval active interval (as fractions of nominalL1 !!!)
+     */
+    static createTruncatedClothoid(spiralType: string, localToWorld: Transform, numXTerm: number, numYTerm: number, originalProperties: TransitionConditionalProperties | undefined, nominalL1: number, nominalR1: number, activeInterval: Segment1d | undefined): DirectSpiral3d | undefined;
+    /**
+     * Create an Japanese spiral clothoid approximation
+     *   * X is 1 terms of the clothoid series as a function of nominal distance along.
+     *   * Y is 1 terms f the clothoid series as a function of nominal distance along.
+     *   * Remark: This is identical to the ChineseCubic
+     * @param localToWorld axes with inflection at origin, tangent along x axis
+     * @param nominalL1 nominal length as used in series LR terms.
+     * @param nominalR1 nominal final radius as used in series LR terms
+     * @param activeInterval fractional interval with (0, nominalL1) range for nominal distance along
+     */
+    static createJapaneseCubic(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create a czech cubic.
+     * This is y= m*x^3 with
+     * * x any point on the x axis
+     * * `fraction` along the spiral goes to `x = fraction * L`
+     * * m is gamma / (6RL)
+     *    * 1/(6RL) is the leading term of the sine series.
+     *    * `gamma = 2R/sqrt (4RR-LL)` pushes y up a little bit to simulate the lost series terms.
+     * @param localToWorld
+     * @param nominalLx nominal length along x axis
+     * @param nominalR1
+     * @param activeInterval
+     */
+    static createCzechCubic(localToWorld: Transform, nominalLx: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create an italian spiral
+     * This is y= m*x^3 with
+     * * x any point on the x axis
+     * * `fraction` along the spiral goes to `x = fraction * L`
+     * * m is gamma / (6RL)
+     *    * 1/(6RL) is the leading term of the sine series.
+     *    * `gamma = 2R/sqrt (4RR-LL)` pushes y up a little bit to simulate the lost series terms.
+     * * L in gamma and m is the
+     * @param localToWorld
+     * @param nominalL1 nominal length along the spiral
+     * @param nominalR1
+     * @param activeInterval
+     */
+    static createItalian(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create an MX Cubic whose nominal length is close to along the curve.
+     * This is y= m*x^3 with
+     * * m is 1/ (6RL1)
+     *    * 1/(6RL) is the leading term of the sine series.
+     * * L1 is an along-the-x-axis distance that is slightly LESS THAN the nominal length
+     * * x is axis position that is slightly LESS than nominal distance along
+     * * L1, x use the approximation   `x = s * ( 1 - s^4/ (40 R R L L))
+     * @param localToWorld
+     * @param nominalL1
+     * @param nominalR1
+     * @param activeInterval
+     */
+    static createMXCubicAlongArc(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create a polish cubic
+     * This is y= m*x^3 with
+     * * m is 1/ (6RL)
+     *    * 1/(6RL) is the leading term of the sine series.
+     * * L is nominal length
+     * * R is nominal end radius.
+     * * x ranges up to the x axis distance for which the polish distance series produces f(x)=L
+     * * The support class PolishCubicEvaluator has static methods for the distance series and its inversion.
+     */
+    static createPolishCubic(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create an AustralianRailCorp spiral
+     * This is y= m*x^3 with
+     * * x any point on the x axis
+     * * `fraction` along the spiral goes to `x = fraction * L`
+     * * m is gamma / (6RL)
+     *    * 1/(6RL) is the leading term of the sine series.
+     *    * `gamma = 2R/sqrt (4RR-LL)` pushes y up a little bit to simulate the lost series terms.
+     * @param localToWorld
+     * @param nominalL1
+     * @param nominalR1
+     * @param activeInterval
+     */
+    static createAustralianRail(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    static createDirectHalfCosine(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create an Arema spiral clothoid approximation
+     *   * X is 2 terms of the clothoid series as a function of nominal distance along
+     *   * Y is 2 terms f the clothoid series as a function of nominal distance along
+     *   * Remark: This is identical to the ChineseCubic
+     * @param localToWorld axes with inflection at origin, tangent along x axis
+     * @param nominalL1 nominal length as used in series LR terms.
+     * @param nominalR1 nominal final radius as used in series LR terms
+     * @param activeInterval fractional interval with (0, nominalL1) range for nominal distance along
+     */
+    static createArema(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create a Chinese clothoid approximation
+     *   * X is 2 terms of the clothoid series as a function of nominal distance along
+     *   * Y is 2 terms f the clothoid series as a function of nominal distance along
+     *   * Remark: This is identical to the Arema spiral
+     * @param localToWorld axes with inflection at origin, tangent along x axis
+     * @param nominalL1 nominal length as used in series LR terms.
+     * @param nominalR1 nominal final radius as used in series LR terms
+     * @param activeInterval fractional interval with (0, nominalL1) range for nominal distance along
+     */
+    static createChineseCubic(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create a Western Australian direct spiral.
+     *   * X is 2 terms of the clothoid series as a function of distance along
+     *   * Y is 1 term (cubic in nominal distance along)
+     * @param localToWorld axes with inflection at origin, tangent along x axis
+     * @param nominalL1 nominal length as used in series LR terms.
+     * @param nominalR1 nominal final radius as used in series LR terms
+     * @param activeInterval fractional interval with (0, nominalL1) range for nominal distance along
+     */
+    static createWesternAustralian(localToWorld: Transform, nominalL1: number, nominalR1: number, activeInterval?: Segment1d): DirectSpiral3d | undefined;
+    /**
+     * Create (if possible) a DirectSpiral3d, applying various strict conditions appropriate to the spiral type.
+     * The parameter list includes extraneous values in order to directly match IntegratedSpiral3d.create, which has greater flexibility about
+     *    mixtures of values.
+     * * IMPORTANT RESTRICTIONS
+     *   * Direct spirals must have the inflection at the origin of their coordinate system, aligned with the x axis.
+     *      * hence bearing0 = 0
+     *      * hence radius0 = 0
+     *   * bearing1 is ignored
+     *   * radius1 must be given.
+     *   * arcLength must be given,
+     * @param spiralType one of the types in `DirectSpiralTypeNames`
+     * @param radius0 radius (or 0 for tangent to line) at start.   Must be ZERO or UNDEFINED
+     * @param radius1 radius (or 0 for tangent to line) at end.
+     * @param bearing0 bearing, measured CCW from x axis at start.   Must be ZERO or UNDEFINED
+     * @param bearing1 bearing, measured CCW from x axis at end.    IGNORED.
+     * @param fractionInterval optional fractional interval for an "active" portion of the curve.   if omitted, the full [0,1] is used.
+     * @param localToWorld placement transform
+     */
+    static createFromLengthAndRadius(spiralType: string, radius0: number | undefined, radius1: number | undefined, bearing0: Angle | undefined, _bearing1: Angle | undefined, arcLength: number | undefined, activeInterval: undefined | Segment1d, localToWorld: Transform): TransitionSpiral3d | undefined;
+    /** Deep clone of this spiral */
+    clone(): DirectSpiral3d;
+    /** Return (if possible) a spiral which is a portion of this curve. */
+    clonePartialCurve(fractionA: number, fractionB: number): DirectSpiral3d | undefined;
+    /** apply `transform` to this spiral's local to world transform. */
+    tryTransformInPlace(transformA: Transform): boolean;
+    /** Clone with a transform applied  */
+    cloneTransformed(transform: Transform): DirectSpiral3d;
+    /** Return the spiral start point. */
+    startPoint(): Point3d;
+    /** return the spiral end point. */
+    endPoint(): Point3d;
+    /** test if the local to world transform places the spiral xy plane into `plane` */
+    isInPlane(plane: Plane3dByOriginAndUnitNormal): boolean;
+    /** Return quick length of the spiral.
+     * The tangent vector of a true clothoid is length 1 everywhere, so simple proportion of nominalL1 is a good approximation.
+     */
+    quickLength(): number;
+    /** Return length of the spiral.
+     * * True length is stored at back of uvParams . . .
+     */
+    /** Test if `other` is an instance of `TransitionSpiral3d` */
+    isSameGeometryClass(other: any): boolean;
+    /** Add strokes from this spiral to `dest`.
+     * * Linestrings will usually stroke as just their points.
+     * * If maxEdgeLength is given, this will sub-stroke within the linestring -- not what we want.
+     */
+    emitStrokes(dest: LineString3d, options?: StrokeOptions): void;
+    /** emit stroke fragments to `dest` handler. */
+    emitStrokableParts(dest: IStrokeHandler, options?: StrokeOptions): void;
+    /**
+     * return the stroke count required for given options.
+     * @param options StrokeOptions that determine count
+     */
+    computeStrokeCountForOptions(options?: StrokeOptions): number;
+    /** Reverse the active interval and active strokes.
+     * * Primary defining data remains unchanged !!!
+     */
+    reverseInPlace(): void;
+    /** Evaluate curve point with respect to fraction. */
+    fractionToPoint(activeFraction: number, result?: Point3d): Point3d;
+    /** Evaluate curve point and derivative with respect to fraction. */
+    fractionToPointAndDerivative(activeFraction: number, result?: Ray3d): Ray3d;
+    /** Return a plane with
+     *
+     * * origin at fractional position along the curve
+     * * vectorU is the first derivative, i.e. tangent vector with length equal to the rate of change with respect to the fraction.
+     * * vectorV is the second derivative, i.e.derivative of vectorU.
+     */
+    fractionToPointAnd2Derivatives(activeFraction: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors | undefined;
+    /** Second step of double dispatch:  call `handler.handleTransitionSpiral(this)` */
+    dispatchToGeometryHandler(handler: GeometryHandler): any;
+    /** extend the range by the strokes of the spiral */
+    extendRange(rangeToExtend: Range3d, transform?: Transform): void;
+    /** compare various coordinate quantities */
+    isAlmostEqual(other: any): boolean;
+}
+//# sourceMappingURL=DirectSpiral3d.d.ts.map