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

package/lib/esm/geometry3d/GeometryHandler.js

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/**
+ * * `GeometryHandler` defines the base abstract methods for double-dispatch geometry computation.
+ * * User code that wants to handle one or all of the commonly known geometry types implements a handler class.
+ * * User code that does not handle all types is most likely to start with `NullGeometryHandler`, which will provide no-action implementations for all types.
+ * @public
+ */
+export class GeometryHandler {
+    /** handle strongly typed  [[CurveCollection]]  */
+    handleCurveCollection(_g) { }
+    /** handle strongly typed Path (base class method calls handleCurveCollection) */
+    handlePath(g) { return this.handleCurveCollection(g); }
+    /** handle strongly typed  Loop (base class method calls handleCurveCollection) */
+    handleLoop(g) { return this.handleCurveCollection(g); }
+    /** handle strongly typed  ParityRegion (base class method calls handleCurveCollection) */
+    handleParityRegion(g) { return this.handleCurveCollection(g); }
+    /** handle strongly typed  UnionRegion (base class method calls handleCurveCollection) */
+    handleUnionRegion(g) { return this.handleCurveCollection(g); }
+    /** handle strongly typed  BagOfCurves (base class method calls handleCurveCollection) */
+    handleBagOfCurves(g) { return this.handleCurveCollection(g); }
+}
+/**
+ * `NullGeometryHandler` is a base class for dispatching various geometry types to
+ * application specific implementation of some service.
+ *
+ * To use:
+ * * Derive a class from `NullGeometryHandler`
+ * * Reimplement any or all of the specific `handleXXXX` methods
+ * * Create a handler instance `myHandler`
+ * * To send a `GeometryQuery` object `candidateGeometry` through the (fast) dispatch, invoke   `candidateGeometry.dispatchToHandler (myHandler)
+ * * The appropriate method or methods will get called with a strongly typed `_g ` value.
+ * @public
+ */
+export class NullGeometryHandler extends GeometryHandler {
+    /** no-action implementation */
+    handleLineSegment3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleLineString3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleArc3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleCurveCollection(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleInterpolationCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleAkimaCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineCurve3dH(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineSurface3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleCoordinateXYZ(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineSurface3dH(_g) { return undefined; }
+    /** no-action implementation */
+    handleIndexedPolyface(_g) { return undefined; }
+    /** no-action implementation
+     * @alpha
+     */
+    handleTransitionSpiral(_g) { return undefined; }
+    /** no-action implementation */
+    handlePath(_g) { return undefined; }
+    /** no-action implementation */
+    handleLoop(_g) { return undefined; }
+    /** no-action implementation */
+    handleParityRegion(_g) { return undefined; }
+    /** no-action implementation */
+    handleUnionRegion(_g) { return undefined; }
+    /** no-action implementation */
+    handleBagOfCurves(_g) { return undefined; }
+    /** no-action implementation */
+    handleSphere(_g) { return undefined; }
+    /** no-action implementation */
+    handleCone(_g) { return undefined; }
+    /** no-action implementation */
+    handleBox(_g) { return undefined; }
+    /** no-action implementation */
+    handleTorusPipe(_g) { return undefined; }
+    /** no-action implementation */
+    handleLinearSweep(_g) { return undefined; }
+    /** no-action implementation */
+    handleRotationalSweep(_g) { return undefined; }
+    /** no-action implementation */
+    handleRuledSweep(_g) { return undefined; }
+    /** no-action implementation */
+    handlePointString3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBezierCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBezierCurve3dH(_g) { return undefined; }
+}
+/**
+ * Implement GeometryHandler methods, with all curve collection methods recursing to children.
+ * @public
+ */
+export class RecurseToCurvesGeometryHandler extends GeometryHandler {
+    /** no-action implementation */
+    handleLineSegment3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleLineString3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleArc3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleInterpolationCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleAkimaCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineCurve3dH(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineSurface3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleCoordinateXYZ(_g) { return undefined; }
+    /** no-action implementation */
+    handleBSplineSurface3dH(_g) { return undefined; }
+    /** no-action implementation */
+    handleIndexedPolyface(_g) { return undefined; }
+    /** no-action implementation
+     * @alpha
+     */
+    handleTransitionSpiral(_g) { return undefined; }
+    /** Invoke `child.dispatchToGeometryHandler(this)` for each child in the array returned by the query `g.children` */
+    handleChildren(g) {
+        const children = g.children;
+        if (children)
+            for (const child of children) {
+                child.dispatchToGeometryHandler(this);
+            }
+    }
+    /** Recurse to children */
+    handleCurveCollection(g) { return this.handleChildren(g); }
+    /** Recurse to children */
+    handlePath(g) { return this.handleChildren(g); }
+    /** Recurse to children */
+    handleLoop(g) { return this.handleChildren(g); }
+    /** Recurse to children */
+    handleParityRegion(g) { return this.handleChildren(g); }
+    /** Recurse to children */
+    handleUnionRegion(g) { return this.handleChildren(g); }
+    /** Recurse to children */
+    handleBagOfCurves(g) { return this.handleChildren(g); }
+    /** no-action implementation */
+    handleSphere(_g) { return undefined; }
+    /** no-action implementation */
+    handleCone(_g) { return undefined; }
+    /** no-action implementation */
+    handleBox(_g) { return undefined; }
+    /** no-action implementation */
+    handleTorusPipe(_g) { return undefined; }
+    /** no-action implementation */
+    handleLinearSweep(_g) { return undefined; }
+    /** no-action implementation */
+    handleRotationalSweep(_g) { return undefined; }
+    /** no-action implementation */
+    handleRuledSweep(_g) { return undefined; }
+    /** no-action implementation */
+    handlePointString3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBezierCurve3d(_g) { return undefined; }
+    /** no-action implementation */
+    handleBezierCurve3dH(_g) { return undefined; }
+}
+//# sourceMappingURL=GeometryHandler.js.map

package/lib/esm/geometry3d/GeometryHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeometryHandler.js","sourceRoot":"","sources":["../../../src/geometry3d/GeometryHandler.ts"],"names":[],"mappings":"AAAA;;;+FAG+F;AAuC/F;;;;;GAKG;AACH,MAAM,OAAgB,eAAe;IAOnC,kDAAkD;IAC3C,qBAAqB,CAAC,EAAmB,IAAS,CAAC;IAsB1D,iFAAiF;IAC1E,UAAU,CAAC,CAAO,IAAS,OAAO,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,kFAAkF;IAC3E,UAAU,CAAC,CAAO,IAAS,OAAO,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,0FAA0F;IACnF,kBAAkB,CAAC,CAAe,IAAS,OAAO,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzF,yFAAyF;IAClF,iBAAiB,CAAC,CAAc,IAAS,OAAO,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACvF,yFAAyF;IAClF,iBAAiB,CAAC,CAAc,IAAS,OAAO,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAsBxF;AACD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,mBAAoB,SAAQ,eAAe;IACtD,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,kBAAkB,CAAC,EAAgB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtE,+BAA+B;IACxB,WAAW,CAAC,EAAS,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxD,+BAA+B;IACf,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACrF,+BAA+B;IACxB,oBAAoB,CAAC,EAAkB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC1E,+BAA+B;IACxB,0BAA0B,CAAC,EAAwB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtF,+BAA+B;IACxB,kBAAkB,CAAC,EAAgB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtE,+BAA+B;IACxB,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC5E,+BAA+B;IACxB,sBAAsB,CAAC,EAAoB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAE9E,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,uBAAuB,CAAC,EAAqB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAChF,+BAA+B;IACxB,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC5E;;OAEG;IACI,sBAAsB,CAAC,EAAsB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAEhF,+BAA+B;IACf,UAAU,CAAC,EAAQ,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC/D,+BAA+B;IACf,UAAU,CAAC,EAAQ,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC/D,+BAA+B;IACf,kBAAkB,CAAC,EAAgB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC/E,+BAA+B;IACf,iBAAiB,CAAC,EAAe,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC7E,+BAA+B;IACf,iBAAiB,CAAC,EAAe,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAE7E,+BAA+B;IACxB,YAAY,CAAC,EAAU,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC1D,+BAA+B;IACxB,UAAU,CAAC,EAAQ,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtD,+BAA+B;IACxB,SAAS,CAAC,EAAO,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACpD,+BAA+B;IACxB,eAAe,CAAC,EAAa,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAChE,+BAA+B;IACxB,iBAAiB,CAAC,EAAe,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACpE,+BAA+B;IACxB,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC5E,+BAA+B;IACxB,gBAAgB,CAAC,EAAc,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAClE,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,oBAAoB,CAAC,EAAkB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;CAC3E;AACD;;;GAGG;AACH,MAAM,OAAO,8BAA+B,SAAQ,eAAe;IACjE,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,kBAAkB,CAAC,EAAgB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtE,+BAA+B;IACxB,WAAW,CAAC,EAAS,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxD,+BAA+B;IACxB,oBAAoB,CAAC,EAAkB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC1E,+BAA+B;IACxB,0BAA0B,CAAC,EAAwB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtF,+BAA+B;IACxB,kBAAkB,CAAC,EAAgB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtE,+BAA+B;IACxB,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC5E,+BAA+B;IACxB,sBAAsB,CAAC,EAAoB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAE9E,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,uBAAuB,CAAC,EAAqB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAChF,+BAA+B;IACxB,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC5E;;OAEG;IACI,sBAAsB,CAAC,EAAsB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAChF,oHAAoH;IAC7G,cAAc,CAAC,CAAgB;QACpC,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC;QAC5B,IAAI,QAAQ;YACV,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE;gBAC5B,KAAK,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC;aACvC;IACL,CAAC;IACD,0BAA0B;IACV,qBAAqB,CAAC,CAAkB,IAAS,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEjG,0BAA0B;IACV,UAAU,CAAC,CAAO,IAAS,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,0BAA0B;IACV,UAAU,CAAC,CAAO,IAAS,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,0BAA0B;IACV,kBAAkB,CAAC,CAAe,IAAS,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3F,0BAA0B;IACV,iBAAiB,CAAC,CAAc,IAAS,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzF,0BAA0B;IACV,iBAAiB,CAAC,CAAc,IAAS,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzF,+BAA+B;IACxB,YAAY,CAAC,EAAU,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC1D,+BAA+B;IACxB,UAAU,CAAC,EAAQ,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACtD,+BAA+B;IACxB,SAAS,CAAC,EAAO,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACpD,+BAA+B;IACxB,eAAe,CAAC,EAAa,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAChE,+BAA+B;IACxB,iBAAiB,CAAC,EAAe,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACpE,+BAA+B;IACxB,qBAAqB,CAAC,EAAmB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAC5E,+BAA+B;IACxB,gBAAgB,CAAC,EAAc,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IAClE,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,mBAAmB,CAAC,EAAiB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;IACxE,+BAA+B;IACxB,oBAAoB,CAAC,EAAkB,IAAS,OAAO,SAAS,CAAC,CAAC,CAAC;CAC3E","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 ArraysAndInterfaces\r\n */\r\n\r\nimport { AkimaCurve3d } from \"../bspline/AkimaCurve3d\";\r\nimport { BezierCurve3d } from \"../bspline/BezierCurve3d\";\r\nimport { BezierCurve3dH } from \"../bspline/BezierCurve3dH\";\r\nimport { BezierCurveBase } from \"../bspline/BezierCurveBase\";\r\nimport { BSplineCurve3d } from \"../bspline/BSplineCurve\";\r\nimport { BSplineCurve3dH } from \"../bspline/BSplineCurve3dH\";\r\nimport { BSplineSurface3d, BSplineSurface3dH } from \"../bspline/BSplineSurface\";\r\nimport { InterpolationCurve3d } from \"../bspline/InterpolationCurve3d\";\r\nimport { Arc3d } from \"../curve/Arc3d\";\r\nimport { CoordinateXYZ } from \"../curve/CoordinateXYZ\";\r\nimport { BagOfCurves, CurveCollection } from \"../curve/CurveCollection\";\r\nimport { CurvePrimitive } from \"../curve/CurvePrimitive\";\r\nimport { GeometryQuery } from \"../curve/GeometryQuery\";\r\nimport { LineSegment3d } from \"../curve/LineSegment3d\";\r\nimport { LineString3d } from \"../curve/LineString3d\";\r\nimport { Loop } from \"../curve/Loop\";\r\nimport { ParityRegion } from \"../curve/ParityRegion\";\r\nimport { Path } from \"../curve/Path\";\r\nimport { PointString3d } from \"../curve/PointString3d\";\r\nimport { TransitionSpiral3d } from \"../curve/spiral/TransitionSpiral3d\";\r\nimport { UnionRegion } from \"../curve/UnionRegion\";\r\nimport { IndexedPolyface } from \"../polyface/Polyface\";\r\nimport { Box } from \"../solid/Box\";\r\nimport { Cone } from \"../solid/Cone\";\r\nimport { LinearSweep } from \"../solid/LinearSweep\";\r\nimport { RotationalSweep } from \"../solid/RotationalSweep\";\r\nimport { RuledSweep } from \"../solid/RuledSweep\";\r\nimport { Sphere } from \"../solid/Sphere\";\r\nimport { TorusPipe } from \"../solid/TorusPipe\";\r\nimport { Plane3dByOriginAndVectors } from \"./Plane3dByOriginAndVectors\";\r\nimport { Vector2d } from \"./Point2dVector2d\";\r\nimport { Point3d, Vector3d } from \"./Point3dVector3d\";\r\n\r\n/**\r\n * * `GeometryHandler` defines the base abstract methods for double-dispatch geometry computation.\r\n * * User code that wants to handle one or all of the commonly known geometry types implements a handler class.\r\n * * User code that does not handle all types is most likely to start with `NullGeometryHandler`, which will provide no-action implementations for all types.\r\n * @public\r\n */\r\nexport abstract class GeometryHandler {\r\n  /** handle strongly typed [[LineSegment3d]] */\r\n  public abstract handleLineSegment3d(g: LineSegment3d): any;\r\n  /** handle strongly typed  [[LineString3d]]  */\r\n  public abstract handleLineString3d(g: LineString3d): any;\r\n  /** handle strongly typed  [[Arc3d]]  */\r\n  public abstract handleArc3d(g: Arc3d): any;\r\n  /** handle strongly typed  [[CurveCollection]]  */\r\n  public handleCurveCollection(_g: CurveCollection): any { }\r\n  /** handle strongly typed  [[BSplineCurve3d]]  */\r\n  public abstract handleBSplineCurve3d(g: BSplineCurve3d): any;\r\n  /** handle strongly typed  [[InterpolationCurve3d]]  */\r\n  public abstract handleInterpolationCurve3d(g: InterpolationCurve3d): any;\r\n  /** handle strongly typed  [[AkimaCurve3d]]  */\r\n  public abstract handleAkimaCurve3d(g: AkimaCurve3d): any;\r\n  /** handle strongly typed  [[BSplineCurve3dH]]  */\r\n  public abstract handleBSplineCurve3dH(g: BSplineCurve3dH): any;\r\n  /** handle strongly typed  [[BSplineSurface3d]]  */\r\n  public abstract handleBSplineSurface3d(g: BSplineSurface3d): any;\r\n  /** handle strongly typed  [[CoordinateXYZ]]  */\r\n  public abstract handleCoordinateXYZ(g: CoordinateXYZ): any;\r\n  /** handle strongly typed  [[BSplineSurface3dH]]  */\r\n  public abstract handleBSplineSurface3dH(g: BSplineSurface3dH): any;\r\n  /** handle strongly typed  [[IndexedPolyface]]  */\r\n  public abstract handleIndexedPolyface(g: IndexedPolyface): any;\r\n  /** handle strongly typed [[TransitionSpiral3d]]\r\n   * @alpha\r\n   */\r\n  public abstract handleTransitionSpiral(g: TransitionSpiral3d): any;\r\n\r\n  /** handle strongly typed Path (base class method calls handleCurveCollection) */\r\n  public handlePath(g: Path): any { return this.handleCurveCollection(g); }\r\n  /** handle strongly typed  Loop (base class method calls handleCurveCollection) */\r\n  public handleLoop(g: Loop): any { return this.handleCurveCollection(g); }\r\n  /** handle strongly typed  ParityRegion (base class method calls handleCurveCollection) */\r\n  public handleParityRegion(g: ParityRegion): any { return this.handleCurveCollection(g); }\r\n  /** handle strongly typed  UnionRegion (base class method calls handleCurveCollection) */\r\n  public handleUnionRegion(g: UnionRegion): any { return this.handleCurveCollection(g); }\r\n  /** handle strongly typed  BagOfCurves (base class method calls handleCurveCollection) */\r\n  public handleBagOfCurves(g: BagOfCurves): any { return this.handleCurveCollection(g); }\r\n  /** handle strongly typed  BagOfCurves (base class method calls handleCurveCollection) */\r\n  /** handle strongly typed  Sphere */\r\n  public abstract handleSphere(g: Sphere): any;\r\n  /** handle strongly typed  Cone */\r\n  public abstract handleCone(g: Cone): any;\r\n  /** handle strongly typed  Box */\r\n  public abstract handleBox(g: Box): any;\r\n  /** handle strongly typed  TorusPipe */\r\n  public abstract handleTorusPipe(g: TorusPipe): any;\r\n  /** handle strongly typed  LinearSweep */\r\n  public abstract handleLinearSweep(g: LinearSweep): any;\r\n  /** handle strongly typed  RotationalSweep */\r\n  public abstract handleRotationalSweep(g: RotationalSweep): any;\r\n  /** handle strongly typed  RuledSweep */\r\n  public abstract handleRuledSweep(g: RuledSweep): any;\r\n  /** handle strongly typed  PointString3d */\r\n  public abstract handlePointString3d(g: PointString3d): any;\r\n  /** handle strongly typed  BezierCurve3d */\r\n  public abstract handleBezierCurve3d(g: BezierCurve3d): any;\r\n  /** handle strongly typed  BezierCurve3dH */\r\n  public abstract handleBezierCurve3dH(g: BezierCurve3dH): any;\r\n}\r\n/**\r\n * `NullGeometryHandler` is a base class for dispatching various geometry types to\r\n * application specific implementation of some service.\r\n *\r\n * To use:\r\n * * Derive a class from `NullGeometryHandler`\r\n * * Reimplement any or all of the specific `handleXXXX` methods\r\n * * Create a handler instance `myHandler`\r\n * * To send a `GeometryQuery` object `candidateGeometry` through the (fast) dispatch, invoke   `candidateGeometry.dispatchToHandler (myHandler)\r\n * * The appropriate method or methods will get called with a strongly typed `_g ` value.\r\n * @public\r\n */\r\nexport class NullGeometryHandler extends GeometryHandler {\r\n  /** no-action implementation */\r\n  public handleLineSegment3d(_g: LineSegment3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleLineString3d(_g: LineString3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleArc3d(_g: Arc3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public override handleCurveCollection(_g: CurveCollection): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineCurve3d(_g: BSplineCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleInterpolationCurve3d(_g: InterpolationCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleAkimaCurve3d(_g: AkimaCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineCurve3dH(_g: BSplineCurve3dH): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineSurface3d(_g: BSplineSurface3d): any { return undefined; }\r\n\r\n  /** no-action implementation */\r\n  public handleCoordinateXYZ(_g: CoordinateXYZ): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineSurface3dH(_g: BSplineSurface3dH): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleIndexedPolyface(_g: IndexedPolyface): any { return undefined; }\r\n  /** no-action implementation\r\n   * @alpha\r\n   */\r\n  public handleTransitionSpiral(_g: TransitionSpiral3d): any { return undefined; }\r\n\r\n  /** no-action implementation */\r\n  public override handlePath(_g: Path): any { return undefined; }\r\n  /** no-action implementation */\r\n  public override handleLoop(_g: Loop): any { return undefined; }\r\n  /** no-action implementation */\r\n  public override handleParityRegion(_g: ParityRegion): any { return undefined; }\r\n  /** no-action implementation */\r\n  public override handleUnionRegion(_g: UnionRegion): any { return undefined; }\r\n  /** no-action implementation */\r\n  public override handleBagOfCurves(_g: BagOfCurves): any { return undefined; }\r\n\r\n  /** no-action implementation */\r\n  public handleSphere(_g: Sphere): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleCone(_g: Cone): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBox(_g: Box): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleTorusPipe(_g: TorusPipe): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleLinearSweep(_g: LinearSweep): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleRotationalSweep(_g: RotationalSweep): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleRuledSweep(_g: RuledSweep): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handlePointString3d(_g: PointString3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBezierCurve3d(_g: BezierCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBezierCurve3dH(_g: BezierCurve3dH): any { return undefined; }\r\n}\r\n/**\r\n * Implement GeometryHandler methods, with all curve collection methods recursing to children.\r\n * @public\r\n */\r\nexport class RecurseToCurvesGeometryHandler extends GeometryHandler {\r\n  /** no-action implementation */\r\n  public handleLineSegment3d(_g: LineSegment3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleLineString3d(_g: LineString3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleArc3d(_g: Arc3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineCurve3d(_g: BSplineCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleInterpolationCurve3d(_g: InterpolationCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleAkimaCurve3d(_g: AkimaCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineCurve3dH(_g: BSplineCurve3dH): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineSurface3d(_g: BSplineSurface3d): any { return undefined; }\r\n\r\n  /** no-action implementation */\r\n  public handleCoordinateXYZ(_g: CoordinateXYZ): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBSplineSurface3dH(_g: BSplineSurface3dH): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleIndexedPolyface(_g: IndexedPolyface): any { return undefined; }\r\n  /** no-action implementation\r\n   * @alpha\r\n   */\r\n  public handleTransitionSpiral(_g: TransitionSpiral3d): any { return undefined; }\r\n  /** Invoke `child.dispatchToGeometryHandler(this)` for each child in the array returned by the query `g.children` */\r\n  public handleChildren(g: GeometryQuery): any {\r\n    const children = g.children;\r\n    if (children)\r\n      for (const child of children) {\r\n        child.dispatchToGeometryHandler(this);\r\n      }\r\n  }\r\n  /** Recurse to children */\r\n  public override handleCurveCollection(g: CurveCollection): any { return this.handleChildren(g); }\r\n\r\n  /** Recurse to children */\r\n  public override handlePath(g: Path): any { return this.handleChildren(g); }\r\n  /** Recurse to children */\r\n  public override handleLoop(g: Loop): any { return this.handleChildren(g); }\r\n  /** Recurse to children */\r\n  public override handleParityRegion(g: ParityRegion): any { return this.handleChildren(g); }\r\n  /** Recurse to children */\r\n  public override handleUnionRegion(g: UnionRegion): any { return this.handleChildren(g); }\r\n  /** Recurse to children */\r\n  public override handleBagOfCurves(g: BagOfCurves): any { return this.handleChildren(g); }\r\n\r\n  /** no-action implementation */\r\n  public handleSphere(_g: Sphere): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleCone(_g: Cone): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBox(_g: Box): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleTorusPipe(_g: TorusPipe): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleLinearSweep(_g: LinearSweep): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleRotationalSweep(_g: RotationalSweep): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleRuledSweep(_g: RuledSweep): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handlePointString3d(_g: PointString3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBezierCurve3d(_g: BezierCurve3d): any { return undefined; }\r\n  /** no-action implementation */\r\n  public handleBezierCurve3dH(_g: BezierCurve3dH): any { return undefined; }\r\n}\r\n\r\n/** IStrokeHandler is an interface with methods to receive data about curves being stroked.\r\n * CurvePrimitives emitStrokes () methods emit calls to a handler object with these methods.\r\n * The various CurvePrimitive types are free to announce either single points (announcePoint), linear fragments,\r\n * or fractional intervals of the parent curve.\r\n * * handler.startCurvePrimitive (cp) -- announce the curve primitive whose strokes will follow.\r\n * * announcePointTangent (xyz, fraction, tangent) -- announce a single point on the curve.\r\n * * announceIntervalForUniformStepStrokes (cp, numStrokes, fraction0, fraction1) -- announce a fraction\r\n * interval in which the curve can be evaluated (e.g. the handler can call cp->fractionToPointAndDerivative ())\r\n * * announceSegmentInterval (cp, point0, point1, numStrokes, fraction0, fraction1) -- announce\r\n *    that the fractional interval fraction0, fraction1 is a straight line which should be broken into\r\n *    numStrokes strokes.\r\n *   * A LineSegment would make a single call to this.\r\n *   * A LineString would make one call to this for each of its segments, with fractions indicating position\r\n * within the linestring.\r\n * * endCurvePrimitive (cp) -- announce the end of the curve primitive.\r\n * @public\r\n */\r\nexport interface IStrokeHandler {\r\n  /** announce a parent curve primitive\r\n   * * startParentCurvePrimitive() ...endParentCurvePrimitive() are wrapped around startCurvePrimitive and endCurvePrimitive when the interior primitive is a proxy.\r\n   */\r\n  startParentCurvePrimitive(cp: CurvePrimitive): void;\r\n  /** Announce the curve primitive that will be described in subsequent calls. */\r\n  startCurvePrimitive(cp: CurvePrimitive): void;\r\n  /**\r\n   * announce a single point with its fraction and tangent.\r\n   * * (IMPORTANT) the same Point3d and Vector3d will be reset and passed on multiple calls.\r\n   * * (THEREFORE) if the implementation is saving coordinates, it must copy the xyz data out into its own data structure rather than save the references.\r\n   */\r\n  announcePointTangent(xyz: Point3d, fraction: number, tangent: Vector3d): void;\r\n\r\n  /** Announce that curve primitive cp should be evaluated in the specified fraction interval. */\r\n  announceIntervalForUniformStepStrokes(\r\n    cp: CurvePrimitive,\r\n    numStrokes: number,\r\n    fraction0: number,\r\n    fraction1: number): void;\r\n  /** Announce numPoints interpolated between point0 and point1, with associated fractions */\r\n  announceSegmentInterval(\r\n    cp: CurvePrimitive,\r\n    point0: Point3d,\r\n    point1: Point3d,\r\n    numStrokes: number,\r\n    fraction0: number,\r\n    fraction1: number): void;\r\n  /** Announce that all data about `cp` has been announced. */\r\n  endCurvePrimitive(cp: CurvePrimitive): void;\r\n  /** Announce that all data about the parent primitive has been announced. */\r\n  endParentCurvePrimitive(cp: CurvePrimitive): void;\r\n  /**\r\n   * Announce a bezier curve fragment.\r\n   * * this is usually a section of BsplineCurve\r\n   * * If this function is missing, the same interval will be passed to announceIntervalForUniformSteps.\r\n   * @param bezier bezier fragment\r\n   * @param numStrokes suggested number of strokes (uniform in bezier interval 0..1)\r\n   * @param parent parent curve\r\n   * @param spanIndex spanIndex within parent\r\n   * @param fraction0 start fraction on parent curve\r\n   * @param fraction1 end fraction on parent curve\r\n   */\r\n  announceBezierCurve?(\r\n    bezier: BezierCurveBase,\r\n    numStrokes: number,\r\n    parent: CurvePrimitive,\r\n    spandex: number,\r\n    fraction0: number,\r\n    fraction1: number): void;\r\n}\r\n\r\n/**\r\n * Interface with methods for mapping (u,v) fractional coordinates to surface xyz and derivatives.\r\n * @public\r\n */\r\nexport interface UVSurface {\r\n  /**\r\n   * Convert fractional u and v coordinates to surface point\r\n   * @param uFraction fractional coordinate in u direction\r\n   * @param vFraction fractional coordinate in the v direction\r\n   * @param result optional pre-allocated point\r\n   */\r\n  uvFractionToPoint(uFraction: number, vFraction: number, result?: Point3d): Point3d;\r\n  /**\r\n   * Convert fractional u and v coordinates to surface point and in-surface tangent directions.\r\n   * * Remark: the vectors are expected to be non-zero tangents which can be crossed to get a normal.\r\n   * * Hence the are NOT precisely either (a) partial derivatives or (b) frenet vectors\r\n   * @param uFraction fractional coordinate in u direction\r\n   * @param vFraction fractional coordinate in the v direction\r\n   * @param result optional pre-allocated carrier for point and vectors\r\n   */\r\n  uvFractionToPointAndTangents(uFraction: number, vFraction: number, result?: Plane3dByOriginAndVectors): Plane3dByOriginAndVectors;\r\n}\r\n/**\r\n * Interface for queries of distance-along in u and v directions\r\n * @public\r\n */\r\nexport interface UVSurfaceIsoParametricDistance {\r\n  /**\r\n   * * Return a vector whose x and y parts are \"size\" of the surface in the u and v directions.\r\n   * * Sizes are use for applying scaling to mesh parameters\r\n   * * These sizes are (reasonable approximations of) the max curve length along u and v isoparameter lines.\r\n   *   * e.g. for a sphere, these are:\r\n   *      * u direction = distance around the equator\r\n   *      * v direction = distance from south pole to north pole.\r\n   */\r\n  maxIsoParametricDistance(): Vector2d;\r\n}\r\n"]}

package/lib/esm/geometry3d/GrowableBlockedArray.d.ts

@@ -0,0 +1,71 @@
+/** @packageDocumentation
+ * @module ArraysAndInterfaces
+ */
+import { BlockComparisonFunction } from "./GrowableFloat64Array";
+/**
+ * Array of contiguous doubles, indexed by block number and index within block.
+ * * This is essentially a rectangular matrix (two dimensional array), with each block being a row of the matrix.
+ * @public
+ */
+export declare class GrowableBlockedArray {
+    /** underlying contiguous, oversized buffer. */
+    protected _data: Float64Array;
+    /** Number of blocks (matrix rows) in use. */
+    protected _inUse: number;
+    /** number of numbers per block in the array.
+     * * If viewing the array as a two dimensional array, this is the row size.
+     */
+    protected _blockSize: number;
+    constructor(blockSize: number, initialBlocks?: number);
+    /** computed property: length (in blocks, not doubles) */
+    get numBlocks(): number;
+    /** property: number of data values per block */
+    get numPerBlock(): number;
+    /**
+     * Return a single value indexed within a block
+     * @param blockIndex index of block to read
+     * @param indexInBlock  offset within the block
+     */
+    getWithinBlock(blockIndex: number, indexWithinBlock: number): number;
+    /** clear the block count to zero, but maintain the allocated memory */
+    clear(): void;
+    /** Return the capacity in blocks (not doubles) */
+    blockCapacity(): number;
+    /** ensure capacity (in blocks, not doubles) */
+    ensureBlockCapacity(blockCapacity: number): void;
+    /** Add a new block of data.
+     * * If newData has fewer than numPerBlock entries, the remaining part of the new block is zeros.
+     * * If newData has more entries, only the first numPerBlock are taken.
+     */
+    addBlock(newData: number[]): void;
+    /**
+     * Return the starting index of a block of (zero-initialized) doubles at the end.
+     *
+     * * this.data is reallocated if needed to include the new block.
+     * * The inUse count is incremented to include the new block.
+     * * The returned block is an index to the Float64Array (not a block index)
+     */
+    protected newBlockIndex(): number;
+    /** reduce the block count by one. */
+    popBlock(): void;
+    /** convert a block index to the simple index to the underlying Float64Array. */
+    protected blockIndexToDoubleIndex(blockIndex: number): number;
+    /** Access a single double at offset within a block, with index checking and return undefined if indexing is invalid. */
+    checkedComponent(blockIndex: number, componentIndex: number): number | undefined;
+    /** Access a single double at offset within a block.  This has no index checking. */
+    component(blockIndex: number, componentIndex: number): number;
+    /** compare two blocks in simple lexical order.
+     * @param data data array
+     * @param blockSize number of items to compare
+     * @param ia raw index (not block index) of first block
+     * @param ib raw index (not block index) of second block
+     */
+    static compareLexicalBlock(data: Float64Array, blockSize: number, ia: number, ib: number): number;
+    /** Return an array of block indices sorted per compareLexicalBlock function */
+    sortIndicesLexical(compareBlocks?: BlockComparisonFunction): Uint32Array;
+    /** Return the distance (hypotenuse=sqrt(summed squares)) between indicated blocks */
+    distanceBetweenBlocks(blockIndexA: number, blockIndexB: number): number;
+    /** Return the distance (hypotenuse=sqrt(summed squares)) between block entries `iBegin <= i < iEnd` of indicated blocks */
+    distanceBetweenSubBlocks(blockIndexA: number, blockIndexB: number, iBegin: number, iEnd: number): number;
+}
+//# sourceMappingURL=GrowableBlockedArray.d.ts.map

package/lib/esm/geometry3d/GrowableBlockedArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrowableBlockedArray.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableBlockedArray.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,+CAA+C;IAC/C,SAAS,CAAC,KAAK,EAAE,YAAY,CAAC;IAC9B,6CAA6C;IAC7C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;gBACV,SAAS,EAAE,MAAM,EAAE,aAAa,GAAE,MAAU;IAS/D,yDAAyD;IACzD,IAAW,SAAS,IAAI,MAAM,CAAwB;IACtD,gDAAgD;IAChD,IAAW,WAAW,IAAI,MAAM,CAA4B;IAC5D;;;;OAIG;IACI,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM;IAG3E,uEAAuE;IAChE,KAAK;IACZ,kDAAkD;IAC3C,aAAa;IAGpB,+CAA+C;IACxC,mBAAmB,CAAC,aAAa,EAAE,MAAM;IAShD;;;OAGG;IACI,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE;IAQjC;;;;;;OAMG;IACH,SAAS,CAAC,aAAa,IAAI,MAAM;IASjC,qCAAqC;IAC9B,QAAQ;IAIf,gFAAgF;IAChF,SAAS,CAAC,uBAAuB,CAAC,UAAU,EAAE,MAAM;IACpD,wHAAwH;IACjH,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKvF,oFAAoF;IAC7E,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;IAGpE;;;;;OAKG;WACW,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAWxG,+EAA+E;IACxE,kBAAkB,CAAC,aAAa,GAAE,uBAAkE,GAAG,WAAW;IAezH,qFAAqF;IAC9E,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;IAa9E,2HAA2H;IACpH,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;CAYhH"}

package/lib/esm/geometry3d/GrowableBlockedArray.js

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module ArraysAndInterfaces
+ */
+/**
+ * Array of contiguous doubles, indexed by block number and index within block.
+ * * This is essentially a rectangular matrix (two dimensional array), with each block being a row of the matrix.
+ * @public
+ */
+export class GrowableBlockedArray {
+    constructor(blockSize, initialBlocks = 8) {
+        /** array contents in blocked (row-major) order, possibly with extra capacity
+         * Total capacity is `this._data.length`
+         * Actual in-use count is `this._inUse * this._blockSize`
+         */
+        this._data = new Float64Array(initialBlocks * blockSize);
+        this._inUse = 0;
+        this._blockSize = blockSize;
+    }
+    /** computed property: length (in blocks, not doubles) */
+    get numBlocks() { return this._inUse; }
+    /** property: number of data values per block */
+    get numPerBlock() { return this._blockSize; }
+    /**
+     * Return a single value indexed within a block
+     * @param blockIndex index of block to read
+     * @param indexInBlock  offset within the block
+     */
+    getWithinBlock(blockIndex, indexWithinBlock) {
+        return this._data[blockIndex * this._blockSize + indexWithinBlock];
+    }
+    /** clear the block count to zero, but maintain the allocated memory */
+    clear() { this._inUse = 0; }
+    /** Return the capacity in blocks (not doubles) */
+    blockCapacity() {
+        return this._data.length / this._blockSize;
+    }
+    /** ensure capacity (in blocks, not doubles) */
+    ensureBlockCapacity(blockCapacity) {
+        if (blockCapacity > this.blockCapacity()) {
+            const newData = new Float64Array(blockCapacity * this._blockSize);
+            for (let i = 0; i < this._data.length; i++) {
+                newData[i] = this._data[i];
+            }
+            this._data = newData;
+        }
+    }
+    /** Add a new block of data.
+     * * If newData has fewer than numPerBlock entries, the remaining part of the new block is zeros.
+     * * If newData has more entries, only the first numPerBlock are taken.
+     */
+    addBlock(newData) {
+        const k0 = this.newBlockIndex();
+        let numValue = newData.length;
+        if (numValue > this._blockSize)
+            numValue = this._blockSize;
+        for (let i = 0; i < numValue; i++)
+            this._data[k0 + i] = newData[i];
+    }
+    /**
+     * Return the starting index of a block of (zero-initialized) doubles at the end.
+     *
+     * * this.data is reallocated if needed to include the new block.
+     * * The inUse count is incremented to include the new block.
+     * * The returned block is an index to the Float64Array (not a block index)
+     */
+    newBlockIndex() {
+        const index = this._blockSize * this._inUse;
+        if ((index + 1) > this._data.length)
+            this.ensureBlockCapacity(1 + 2 * this._inUse);
+        this._inUse++;
+        for (let i = index; i < index + this._blockSize; i++)
+            this._data[i] = 0.0;
+        return index;
+    }
+    /** reduce the block count by one. */
+    popBlock() {
+        if (this._inUse > 0)
+            this._inUse--;
+    }
+    /** convert a block index to the simple index to the underlying Float64Array. */
+    blockIndexToDoubleIndex(blockIndex) { return this._blockSize * blockIndex; }
+    /** Access a single double at offset within a block, with index checking and return undefined if indexing is invalid. */
+    checkedComponent(blockIndex, componentIndex) {
+        if (blockIndex >= this._inUse || blockIndex < 0 || componentIndex < 0 || componentIndex >= this._blockSize)
+            return undefined;
+        return this._data[this._blockSize * blockIndex + componentIndex];
+    }
+    /** Access a single double at offset within a block.  This has no index checking. */
+    component(blockIndex, componentIndex) {
+        return this._data[this._blockSize * blockIndex + componentIndex];
+    }
+    /** compare two blocks in simple lexical order.
+     * @param data data array
+     * @param blockSize number of items to compare
+     * @param ia raw index (not block index) of first block
+     * @param ib raw index (not block index) of second block
+     */
+    static compareLexicalBlock(data, blockSize, ia, ib) {
+        let ax = 0;
+        let bx = 0;
+        for (let i = 0; i < blockSize; i++) {
+            ax = data[ia + i];
+            bx = data[ib + i];
+            if (ax > bx)
+                return 1;
+            if (ax < bx)
+                return -1;
+        }
+        return ia - ib; // so original order is maintained among duplicates !!!!
+    }
+    /** Return an array of block indices sorted per compareLexicalBlock function */
+    sortIndicesLexical(compareBlocks = GrowableBlockedArray.compareLexicalBlock) {
+        const n = this._inUse;
+        // let numCompare = 0;
+        const result = new Uint32Array(n);
+        const data = this._data;
+        const blockSize = this._blockSize;
+        for (let i = 0; i < n; i++)
+            result[i] = i;
+        result.sort((blockIndexA, blockIndexB) => {
+            // numCompare++;
+            return compareBlocks(data, blockSize, blockIndexA * blockSize, blockIndexB * blockSize);
+        });
+        // console.log (n, numCompare);
+        return result;
+    }
+    /** Return the distance (hypotenuse=sqrt(summed squares)) between indicated blocks */
+    distanceBetweenBlocks(blockIndexA, blockIndexB) {
+        let dd = 0.0;
+        let iA = this.blockIndexToDoubleIndex(blockIndexA);
+        let iB = this.blockIndexToDoubleIndex(blockIndexB);
+        let a = 0;
+        const data = this._data;
+        for (let i = 0; i < this._blockSize; i++) {
+            a = data[iA++] - data[iB++];
+            dd += a * a;
+        }
+        return Math.sqrt(dd);
+    }
+    /** Return the distance (hypotenuse=sqrt(summed squares)) between block entries `iBegin <= i < iEnd` of indicated blocks */
+    distanceBetweenSubBlocks(blockIndexA, blockIndexB, iBegin, iEnd) {
+        let dd = 0.0;
+        const iA = this.blockIndexToDoubleIndex(blockIndexA);
+        const iB = this.blockIndexToDoubleIndex(blockIndexB);
+        let a = 0;
+        const data = this._data;
+        for (let i = iBegin; i < iEnd; i++) {
+            a = data[iA + i] - data[iB + i];
+            dd += a * a;
+        }
+        return Math.sqrt(dd);
+    }
+}
+//# sourceMappingURL=GrowableBlockedArray.js.map

package/lib/esm/geometry3d/GrowableBlockedArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrowableBlockedArray.js","sourceRoot":"","sources":["../../../src/geometry3d/GrowableBlockedArray.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/** @packageDocumentation\r\n * @module ArraysAndInterfaces\r\n */\r\n\r\nimport { BlockComparisonFunction } from \"./GrowableFloat64Array\";\r\n\r\n/**\r\n * Array of contiguous doubles, indexed by block number and index within block.\r\n * * This is essentially a rectangular matrix (two dimensional array), with each block being a row of the matrix.\r\n * @public\r\n */\r\nexport class GrowableBlockedArray {\r\n  /** underlying contiguous, oversized buffer. */\r\n  protected _data: Float64Array;\r\n  /** Number of blocks (matrix rows) in use. */\r\n  protected _inUse: number;\r\n  /** number of numbers per block in the array.\r\n   * * If viewing the array as a two dimensional array, this is the row size.\r\n   */\r\n  protected _blockSize: number;  // positive integer !!!\r\n  public constructor(blockSize: number, initialBlocks: number = 8) {\r\n    /** array contents in blocked (row-major) order, possibly with extra capacity\r\n     * Total capacity is `this._data.length`\r\n     * Actual in-use count is `this._inUse * this._blockSize`\r\n     */\r\n    this._data = new Float64Array(initialBlocks * blockSize);\r\n    this._inUse = 0;\r\n    this._blockSize = blockSize;\r\n  }\r\n  /** computed property: length (in blocks, not doubles) */\r\n  public get numBlocks(): number { return this._inUse; }\r\n  /** property: number of data values per block */\r\n  public get numPerBlock(): number { return this._blockSize; }\r\n  /**\r\n   * Return a single value indexed within a block\r\n   * @param blockIndex index of block to read\r\n   * @param indexInBlock  offset within the block\r\n   */\r\n  public getWithinBlock(blockIndex: number, indexWithinBlock: number): number {\r\n    return this._data[blockIndex * this._blockSize + indexWithinBlock];\r\n  }\r\n  /** clear the block count to zero, but maintain the allocated memory */\r\n  public clear() { this._inUse = 0; }\r\n  /** Return the capacity in blocks (not doubles) */\r\n  public blockCapacity() {\r\n    return this._data.length / this._blockSize;\r\n  }\r\n  /** ensure capacity (in blocks, not doubles) */\r\n  public ensureBlockCapacity(blockCapacity: number) {\r\n    if (blockCapacity > this.blockCapacity()) {\r\n      const newData = new Float64Array(blockCapacity * this._blockSize);\r\n      for (let i = 0; i < this._data.length; i++) {\r\n        newData[i] = this._data[i];\r\n      }\r\n      this._data = newData;\r\n    }\r\n  }\r\n  /** Add a new block of data.\r\n   * * If newData has fewer than numPerBlock entries, the remaining part of the new block is zeros.\r\n   * * If newData has more entries, only the first numPerBlock are taken.\r\n   */\r\n  public addBlock(newData: number[]) {\r\n    const k0 = this.newBlockIndex();\r\n    let numValue = newData.length;\r\n    if (numValue > this._blockSize)\r\n      numValue = this._blockSize;\r\n    for (let i = 0; i < numValue; i++)\r\n      this._data[k0 + i] = newData[i];\r\n  }\r\n  /**\r\n   * Return the starting index of a block of (zero-initialized) doubles at the end.\r\n   *\r\n   * * this.data is reallocated if needed to include the new block.\r\n   * * The inUse count is incremented to include the new block.\r\n   * * The returned block is an index to the Float64Array (not a block index)\r\n   */\r\n  protected newBlockIndex(): number {\r\n    const index = this._blockSize * this._inUse;\r\n    if ((index + 1) > this._data.length)\r\n      this.ensureBlockCapacity(1 + 2 * this._inUse);\r\n    this._inUse++;\r\n    for (let i = index; i < index + this._blockSize; i++)\r\n      this._data[i] = 0.0;\r\n    return index;\r\n  }\r\n  /** reduce the block count by one. */\r\n  public popBlock() {\r\n    if (this._inUse > 0)\r\n      this._inUse--;\r\n  }\r\n  /** convert a block index to the simple index to the underlying Float64Array. */\r\n  protected blockIndexToDoubleIndex(blockIndex: number) { return this._blockSize * blockIndex; }\r\n  /** Access a single double at offset within a block, with index checking and return undefined if indexing is invalid. */\r\n  public checkedComponent(blockIndex: number, componentIndex: number): number | undefined {\r\n    if (blockIndex >= this._inUse || blockIndex < 0 || componentIndex < 0 || componentIndex >= this._blockSize)\r\n      return undefined;\r\n    return this._data[this._blockSize * blockIndex + componentIndex];\r\n  }\r\n  /** Access a single double at offset within a block.  This has no index checking. */\r\n  public component(blockIndex: number, componentIndex: number): number {\r\n    return this._data[this._blockSize * blockIndex + componentIndex];\r\n  }\r\n  /** compare two blocks in simple lexical order.\r\n   * @param data data array\r\n   * @param blockSize number of items to compare\r\n   * @param ia raw index (not block index) of first block\r\n   * @param ib raw index (not block index) of second block\r\n   */\r\n  public static compareLexicalBlock(data: Float64Array, blockSize: number, ia: number, ib: number): number {\r\n    let ax = 0;\r\n    let bx = 0;\r\n    for (let i = 0; i < blockSize; i++) {\r\n      ax = data[ia + i];\r\n      bx = data[ib + i];\r\n      if (ax > bx) return 1;\r\n      if (ax < bx) return -1;\r\n    }\r\n    return ia - ib; // so original order is maintained among duplicates !!!!\r\n  }\r\n  /** Return an array of block indices sorted per compareLexicalBlock function */\r\n  public sortIndicesLexical(compareBlocks: BlockComparisonFunction = GrowableBlockedArray.compareLexicalBlock): Uint32Array {\r\n    const n = this._inUse;\r\n    // let numCompare = 0;\r\n    const result = new Uint32Array(n);\r\n    const data = this._data;\r\n    const blockSize = this._blockSize;\r\n    for (let i = 0; i < n; i++)result[i] = i;\r\n    result.sort(\r\n      (blockIndexA: number, blockIndexB: number) => {\r\n        // numCompare++;\r\n        return compareBlocks(data, blockSize, blockIndexA * blockSize, blockIndexB * blockSize);\r\n      });\r\n    // console.log (n, numCompare);\r\n    return result;\r\n  }\r\n  /** Return the distance (hypotenuse=sqrt(summed squares)) between indicated blocks */\r\n  public distanceBetweenBlocks(blockIndexA: number, blockIndexB: number): number {\r\n    let dd = 0.0;\r\n    let iA = this.blockIndexToDoubleIndex(blockIndexA);\r\n    let iB = this.blockIndexToDoubleIndex(blockIndexB);\r\n    let a = 0;\r\n    const data = this._data;\r\n    for (let i = 0; i < this._blockSize; i++) {\r\n      a = data[iA++] - data[iB++];\r\n      dd += a * a;\r\n    }\r\n    return Math.sqrt(dd);\r\n  }\r\n\r\n  /** Return the distance (hypotenuse=sqrt(summed squares)) between block entries `iBegin <= i < iEnd` of indicated blocks */\r\n  public distanceBetweenSubBlocks(blockIndexA: number, blockIndexB: number, iBegin: number, iEnd: number): number {\r\n    let dd = 0.0;\r\n    const iA = this.blockIndexToDoubleIndex(blockIndexA);\r\n    const iB = this.blockIndexToDoubleIndex(blockIndexB);\r\n    let a = 0;\r\n    const data = this._data;\r\n    for (let i = iBegin; i < iEnd; i++) {\r\n      a = data[iA + i] - data[iB + i];\r\n      dd += a * a;\r\n    }\r\n    return Math.sqrt(dd);\r\n  }\r\n}\r\n"]}

package/lib/esm/geometry3d/GrowableFloat64Array.d.ts

@@ -0,0 +1,132 @@
+/** @packageDocumentation
+ * @module ArraysAndInterfaces
+ */
+/**
+ * Type for a OptionalGrowableFloat64Array or undefined.
+ * @public
+ */
+export declare type OptionalGrowableFloat64Array = GrowableFloat64Array | undefined;
+/**
+ * Signature for a function which does lexical comparison of `blockSize` consecutive values as 2 starting indices.
+ * @public
+ */
+export declare type BlockComparisonFunction = (data: Float64Array, blockSize: number, index0: number, index1: number) => number;
+/**
+ * A `GrowableFloat64Array` is Float64Array accompanied by a count of how many of the array's entries are considered in use.
+ * * In C++ terms, this is like an std::vector
+ * * As entries are added to the array, the buffer is reallocated as needed to accommodate.
+ * * The reallocations leave unused space to accept further additional entries without reallocation.
+ * * The `length` property returns the number of entries in use.
+ * * the `capacity` property returns the (usually larger) length of the (over-allocated) Float64Array.
+ * @public
+ */
+export declare class GrowableFloat64Array {
+    private _data;
+    private _inUse;
+    constructor(initialCapacity?: number);
+    /**
+     * Create a GrowableFloat64Array with given contents.
+     * @param contents data to copy into the array
+     */
+    static create(contents: Float64Array | number[]): GrowableFloat64Array;
+    /** sort-compatible comparison.
+     * * Returns `(a-b)` which is
+     *   * negative if `a<b`
+     *   * zero if `a === b` (with exact equality)
+     *   * positive if `a>b`
+     */
+    static compare(a: any, b: any): number;
+    /** Return a new array with
+     * * All active entries copied from this instance
+     * * optionally trimmed capacity to the active length or replicate the capacity and unused space.
+     */
+    clone(maintainExcessCapacity?: boolean): GrowableFloat64Array;
+    /**
+     * Returns the number of entries in use.
+     * * Note that this is typically smaller than the length of the length of the supporting `Float64Array`
+     */
+    get length(): number;
+    /**
+     * Set the value at specified index.
+     * @param index index of entry to set
+     * @param value value to set
+     */
+    setAtUncheckedIndex(index: number, value: number): void;
+    /**
+     * Move the value at index i to index j.
+     * @param i source index
+     * @param j destination index.
+     */
+    move(i: number, j: number): void;
+    /**
+     * swap the values at indices i and j
+     * @param i first index
+     * @param j second index
+     */
+    swap(i: number, j: number): void;
+    /**
+     * append a single value to the array.
+     * @param toPush value to append to the active array.
+     */
+    push(toPush: number): void;
+    /**
+     * Push each value from an array.
+     * @param data array of values to push
+     */
+    pushArray(data: Float64Array | number[]): void;
+    /** Push a `numToCopy` consecutive values starting at `copyFromIndex` to the end of the array. */
+    pushBlockCopy(copyFromIndex: number, numToCopy: number): void;
+    /** Clear the array to 0 length.  The underlying memory remains allocated for reuse. */
+    clear(): void;
+    /**
+     * Returns the number of entries in the supporting Float64Array buffer.
+     * * This number can be larger than the `length` property.
+     */
+    capacity(): number;
+    /**
+     * * If the capacity (Float64Array length) is less than or equal to the requested newCapacity, do nothing
+     * * If the requested newCapacity is larger than the existing capacity, reallocate (and copy existing values) with the larger capacity.
+     * @param newCapacity
+     */
+    ensureCapacity(newCapacity: number): void;
+    /**
+     * * If newLength is less than current (active) length, just set (active) length.
+     * * If newLength is greater, ensureCapacity (newSize) and pad with padValue up to newSize;
+     * @param newLength new data count
+     * @param padValue value to use for padding if the length increases.
+     */
+    resize(newLength: number, padValue?: number): void;
+    /**
+     * * Reduce the length by one.
+     * * Note that there is no method return value -- use `back` to get that value before `pop()`
+     * * (As with std::vector, separating the `pop` from the value access eliminates error testing from `pop` call)
+     */
+    pop(): void;
+    /** Access by index, without bounds check */
+    atUncheckedIndex(index: number): number;
+    /** Access the 0-index member, without bounds check */
+    front(): number;
+    /** Access the final member, without bounds check */
+    back(): number;
+    /** set a value by index */
+    reassign(index: number, value: number): void;
+    /**
+     * * Sort the array entries.
+     * * Uses insertion sort -- fine for small arrays (less than 30), slow for larger arrays
+     * @param compareMethod comparison method
+     */
+    sort(compareMethod?: (a: any, b: any) => number): void;
+    /**
+     * * compress out values not within the [a,b] interval.
+     * * Note that if a is greater than b all values are rejected.
+     * @param a low value for accepted interval
+     * @param b high value for accepted interval
+     */
+    restrictToInterval(a: number, b: number): void;
+    /**
+     * * compress out multiple copies of values.
+     * * this is done in the current order of the array.
+     */
+    compressAdjacentDuplicates(tolerance?: number): void;
+}
+//# sourceMappingURL=GrowableFloat64Array.d.ts.map

package/lib/esm/geometry3d/GrowableFloat64Array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GrowableFloat64Array.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/GrowableFloat64Array.ts"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;GAGG;AACH,oBAAY,4BAA4B,GAAG,oBAAoB,GAAG,SAAS,CAAC;AAC5E;;;GAGG;AACH,oBAAY,uBAAuB,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;AACxH;;;;;;;;GAQG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,MAAM,CAAS;gBACX,eAAe,GAAE,MAAU;IAIvC;;;OAGG;WACW,MAAM,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,EAAE,GAAG,oBAAoB;IAO7E;;;;;OAKG;WACW,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM;IAG7C;;;OAGG;IACI,KAAK,CAAC,sBAAsB,GAAE,OAAe,GAAG,oBAAoB;IAQ3E;;;OAGG;IACH,IAAW,MAAM,WAEhB;IACD;;;;OAIG;IACI,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAIvD;;;;OAIG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAGhC;;;;OAIG;IACI,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAMhC;;;OAGG;IACI,IAAI,CAAC,MAAM,EAAE,MAAM;IAe1B;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE;IAG9C,iGAAiG;IAC1F,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAO7D,uFAAuF;IAChF,KAAK;IAIZ;;;OAGG;IACI,QAAQ;IAGf;;;;OAIG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM;IASzC;;;;;OAKG;IACI,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU;IAYrD;;;;OAIG;IACI,GAAG;IAOV,4CAA4C;IACrC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAG9C,sDAAsD;IAC/C,KAAK;IAGZ,oDAAoD;IAC7C,IAAI;IAGX,2BAA2B;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAI5C;;;;OAIG;IACI,IAAI,CAAC,aAAa,GAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,MAAqC;IAapF;;;;;OAKG;IACI,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAa9C;;;OAGG;IACI,0BAA0B,CAAC,SAAS,GAAE,MAAY;CAmB1D"}