@itwin/core-geometry 4.4.0-dev.9 → 4.5.0-dev.0

package/lib/cjs/serialization/GeometrySamples.js

@@ -98,6 +98,9 @@ exports.SteppedIndexFunctionFactory = SteppedIndexFunctionFactory;
  * @internal
  */
 class FrankeSurface {
+    constructor(scales) {
+        this.scales = scales;
+    }
     exp0(u, v) {
         return Math.exp(-0.25 * (u * u + v * v) + u + v - 2);
     }
@@ -115,7 +118,21 @@ class FrankeSurface {
         const f1 = 0.75 * this.exp1(u, v);
         const f2 = 0.5 * this.exp2(u, v);
         const f3 = -0.2 * this.exp3(u, v);
-        return f0 + f1 + f2 + f3;
+        if (this.scales !== undefined) {
+            const numScale = this.scales.length;
+            let f = 0;
+            if (numScale >= 1)
+                f += this.scales[0] * f0;
+            if (numScale >= 2)
+                f += this.scales[1] * f1;
+            if (numScale >= 3)
+                f += this.scales[2] * f2;
+            if (numScale >= 4)
+                f += this.scales[3] * f3;
+            return f;
+        }
+        else
+            return f0 + f1 + f2 + f3;
     }
     du(u, v) {
         const du0 = -3.375 * (u - 2) * this.exp0(u, v);
@@ -2131,6 +2148,40 @@ class Sample {
             point0.push(point0[0].clone());
         return point0;
     }
+    /**
+    * Create a grid of lat-long points on a sphere.
+    * * If pole latitudes appear in the evaluation, a single point (not a circle) is evaluated.
+    * * Circles at various latitudes proceed south to north.
+    * * If first and last angles of longitudeSweep match, that meridian is not duplicated.
+    * * Longitudes can wrap freely.
+     * @param transform local to world
+     * @param numLatitudeStep number of latitude steps (poles count if they are in the sweeps)
+     * @param numLongitudeStep number of longitude steps
+     * @param latitudeSweep angle range for latitudes
+     * @param longitudeSweep angle range for longitudes
+     */
+    static createGridPointsOnEllipsoid(transform, numLatitudeStep, numLongitudeStep, latitudeSweep = AngleSweep_1.AngleSweep.createStartEndDegrees(-90, 90), longitudeSweep = AngleSweep_1.AngleSweep.createStartEndDegrees(0, 360)) {
+        const points = [];
+        const numJ = numLatitudeStep + 1;
+        const jFractionStep = 1.0 / numJ;
+        let numI = numLongitudeStep;
+        const iFractionStep = 1.0 / numI;
+        if (longitudeSweep.isFullCircle)
+            numI--;
+        for (let j = 0; j < numJ; j++) {
+            const phi = latitudeSweep.fractionToRadians(jFractionStep * j);
+            const sinPhi = Math.sin(phi);
+            const cosPhi = Math.cos(phi);
+            const numIThisCircle = Angle_1.Angle.isAlmostEqualRadiansAllowPeriodShift(phi, -90) ? 1 : numI;
+            for (let i = 0; i < numIThisCircle; i++) {
+                const theta = longitudeSweep.fractionToRadians(iFractionStep * i);
+                const cosTheta = Math.cos(theta);
+                const sinTheta = Math.sin(theta);
+                points.push(transform.multiplyXYZ(cosTheta * cosPhi, sinTheta * cosPhi, sinPhi));
+            }
+        }
+        return points;
+    }
     /**
      * Return an array of points on a circular arc.
      * @param edgesPerQuadrant number of edges per 90 degrees
@@ -2221,15 +2272,53 @@ class Sample {
             }
         }
     }
+    /** Create a point on the polar parametric curve r = cos(a * theta), aka "rose".
+     * @param theta angle
+     * @param a period multiplier. If odd, this is the petal count; if even, twice the number of petals.
+     * @param z z-coordinate for output
+    */
+    static createRosePoint3d(theta, a, z = 0) {
+        const r = Math.cos(a * theta);
+        return Point3dVector3d_1.Point3d.create(r * Math.cos(theta), r * Math.sin(theta), z);
+    }
+    /** Create a point on the polar parametric curve r = cos(a * theta), aka "rose".
+     * @param theta angle
+     * @param a period multiplier. If odd, this is the petal count; if even, twice the number of petals.
+    */
+    static createRosePoint2d(theta, a) {
+        return Point2dVector2d_1.Point2d.createFrom(Sample.createRosePoint3d(theta, a));
+    }
     /**
-     * Create a mesh surface from samples of a smooth function over [0,1]x[0,1].
+     * Create a mesh surface from samples of a smooth real-valued function over [0,1]x[0,1] with multiple humps and dips.
+     * * The facets are bilinear quads, so if planar facets are required, set `options.shouldTriangulate = true`.
      * @param size grid size; the number of intervals on each side of the unit square domain.
+     * @param scales = array of 4 (four) numbers to scale the corresponding Franke exponential.  If undefined, all scales are 1.
      */
-    static createMeshFromSmoothSurface(size, options) {
+    static createMeshFromFrankeSurface(size, options, scales) {
         const builder = PolyfaceBuilder_1.PolyfaceBuilder.create(options);
-        builder.addUVGridBody(new FrankeSurface(), size, size);
+        builder.addUVGridBody(new FrankeSurface(scales), size, size);
         return builder.claimPolyface(true);
     }
+    /** Stroke a helix over the unit circle.  Place in space via a transform.
+     * The various columns of the transform become the critical measures for the (elliptic) helix:
+     * The unit cylinder maps to an elliptic cylinder with x and y columns as 0 and 90 degree vectors.
+     * the Helix pitch is equal to the length of the z axis in the transform.
+     * The completeTurns parameter (which does NOT need to be an integer) is the local z of the last point
+     */
+    static createHelixPoints(completeTurns, numPoints, placement) {
+        const points = [];
+        if (numPoints < 2)
+            numPoints = 2;
+        const dThetaRadians = completeTurns * Math.PI * 2 / (numPoints - 1);
+        const dz = completeTurns / (numPoints - 1);
+        for (let i = 0; i < numPoints; i++) {
+            const thetaRadians = dThetaRadians * i;
+            points.push(Point3dVector3d_1.Point3d.create(Math.cos(thetaRadians), Math.sin(thetaRadians), i * dz));
+        }
+        if (placement)
+            placement.multiplyPoint3dArrayInPlace(points);
+        return points;
+    }
 }
 /** Array with assorted Point2d samples */
 Sample.point2d = [