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

package/lib/cjs/polyface/RangeTree/RangeTreeSearchHandlers.d.ts

@@ -0,0 +1,204 @@
+/** @packageDocumentation
+ * @module RangeSearch
+ */
+import { CurveLocationDetail, CurveLocationDetailPair } from "../../curve/CurveLocationDetail";
+import { Point3d } from "../../geometry3d/Point3dVector3d";
+import { Range3d } from "../../geometry3d/Range";
+import { FacetLocationDetail, FacetLocationDetailPair } from "../FacetLocationDetail";
+import { LineString3dRangeTreeContext } from "./LineString3dRangeTreeContext";
+import { MinimumValueTester } from "./MinimumValueTester";
+import { Point3dArrayRangeTreeContext } from "./Point3dArrayRangeTreeContext";
+import { PolyfaceRangeTreeContext } from "./PolyfaceRangeTreeContext";
+import { SingleTreeSearchHandler, TwoTreeDistanceMinimizationSearchHandler } from "./RangeTreeNode";
+/**
+ * Helper class for searching for the closest point in a set of points.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+export declare class SingleTreeSearchHandlerForClosestPointInArray extends SingleTreeSearchHandler<number> {
+    /** The calling context */
+    context: Point3dArrayRangeTreeContext;
+    /** Evolving search state */
+    searchState: MinimumValueTester<number>;
+    /** Space point for the search  */
+    spacePoint: Point3d;
+    /**
+     * Constructor
+     * @param spacePoint cloned
+     * @param context captured
+     * @param maxDist collect points at no more than this distance from spacePoint
+     */
+    constructor(spacePoint: Point3d, context: Point3dArrayRangeTreeContext, maxDist?: number);
+    /** Return the current closest point */
+    getResult(): CurveLocationDetail | undefined;
+    /** Return the collected closest points (if collecting) */
+    getSavedItems(): CurveLocationDetail[] | undefined;
+    /**
+     * Return true if appData within the range should be offered to `processAppData`.
+     * @param range range containing items to be tested.
+     * @returns true if the spacePoint is within the range or close enough that a point in the range could be the closest.
+     */
+    isRangeActive(range: Range3d): boolean;
+    /** Test a point indexed in the range tree as candidate for "closest" */
+    processAppData(candidateIndex: number): void;
+}
+/**
+ * Helper class for searching for the closest approach between sets of points.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+export declare class TwoTreeSearchHandlerForPoint3dArrayPoint3dArrayCloseApproach extends TwoTreeDistanceMinimizationSearchHandler<number> {
+    /** Context for first set of points */
+    contextA: Point3dArrayRangeTreeContext;
+    /** Context for second set of points */
+    contextB: Point3dArrayRangeTreeContext;
+    /** Search state with current min distance point pair */
+    searchState: MinimumValueTester<CurveLocationDetailPair>;
+    /**
+     * Constructor
+     * @param contextA captured
+     * @param contextB captured
+     * @param maxDist collect points at no more than this separation distance
+     */
+    constructor(contextA: Point3dArrayRangeTreeContext, contextB: Point3dArrayRangeTreeContext, maxDist?: number);
+    /** Return the current closest approach */
+    getResult(): CurveLocationDetailPair | undefined;
+    /** Return the collected close approaches (if collecting) */
+    getSavedItems(): CurveLocationDetailPair[] | undefined;
+    /** Get current min distance */
+    getCurrentDistance(): number;
+    /** Compute and test the distance between two points, given their indices. */
+    processAppDataPair(indexA: number, indexB: number): void;
+}
+/**
+ * Helper class for searching for the closest point in a linestring.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+export declare class SingleTreeSearchHandlerForClosestPointOnLineString3d extends SingleTreeSearchHandler<number> {
+    /** The calling context */
+    context: LineString3dRangeTreeContext;
+    /** Evolving search state */
+    searchState: MinimumValueTester<CurveLocationDetail>;
+    /** Space point for the search */
+    spacePoint: Point3d;
+    /**
+     * Constructor
+     * @param spacePoint cloned
+     * @param context captured
+     * @param maxDist collect points at no more than this distance from spacePoint
+     */
+    constructor(spacePoint: Point3d, context: LineString3dRangeTreeContext, maxDist?: number);
+    /** Return the current closest point */
+    getResult(): CurveLocationDetail | undefined;
+    /** Return the collected closest points (if collecting) */
+    getSavedItems(): CurveLocationDetail[] | undefined;
+    /**
+     * Return true if appData within the range should be offered to `processAppData`.
+     * @param range range containing items to be tested.
+     * @returns true if the spacePoint is within the range or close enough that a point in the range could be the closest.
+     */
+    isRangeActive(range: Range3d): boolean;
+    private _workSegment?;
+    /** Test a segment indexed in the range tree as candidate for "closest" */
+    processAppData(candidateIndex: number): void;
+}
+/**
+ * Helper class for searching for the closest approach between linestrings.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+export declare class TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach extends TwoTreeDistanceMinimizationSearchHandler<number> {
+    /** Context for first polyline */
+    contextA: LineString3dRangeTreeContext;
+    /** Context for second polyline */
+    contextB: LineString3dRangeTreeContext;
+    /** Search state with current min distance point pair */
+    searchState: MinimumValueTester<CurveLocationDetailPair>;
+    /**
+     * Constructor
+     * @param contextA captured
+     * @param contextB captured
+     * @param maxDist collect points at no more than this separation distance
+     */
+    constructor(contextA: LineString3dRangeTreeContext, contextB: LineString3dRangeTreeContext, maxDist?: number);
+    /**
+     * Return the current closest approach.
+     * * Details contain linestring *and* segment data, cf. [[LineString3d.convertLocalToGlobalDetail]]
+     */
+    getResult(): CurveLocationDetailPair | undefined;
+    /** Return the collected close approaches (if collecting) */
+    getSavedItems(): CurveLocationDetailPair[] | undefined;
+    /** Get current min distance */
+    getCurrentDistance(): number;
+    private static _workSegmentA?;
+    private static _workSegmentB?;
+    /** Compute and test the closest approach between two segments, given their indices. */
+    processAppDataPair(indexA: number, indexB: number): void;
+}
+/**
+ * Helper class for searching for the closest point in a polyface.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring FacetLocationDetail).
+ * @internal
+ */
+export declare class SingleTreeSearchHandlerForClosestPointOnPolyface extends SingleTreeSearchHandler<number> {
+    /** The calling context */
+    context: PolyfaceRangeTreeContext;
+    /** Evolving search state */
+    searchState: MinimumValueTester<FacetLocationDetail>;
+    /** Space point for the search */
+    spacePoint: Point3d;
+    /** Whether to include facet interior in search */
+    searchFacetInterior: boolean;
+    /**
+     * Constructor
+     * @param spacePoint cloned
+     * @param context captured
+     * @param maxDist collect points at no more than this distance from spacePoint
+     * @param searchFacetInterior true: search facet interior + boundary; false: just boundary
+     */
+    constructor(spacePoint: Point3d, context: PolyfaceRangeTreeContext, maxDist?: number, searchFacetInterior?: boolean);
+    /** Return the current closest point */
+    getResult(): FacetLocationDetail | undefined;
+    /** Return the collected closest points (if collecting) */
+    getSavedItems(): FacetLocationDetail[] | undefined;
+    /**
+     * Return true if appData within the range should be offered to `processAppData`.
+     * @param range range containing items to be tested.
+     * @returns true if the spacePoint is within the range or close enough that a point in the range could be the closest.
+     */
+    isRangeActive(range: Range3d): boolean;
+    /** Test a facet indexed in the range tree as candidate for "closest" */
+    processAppData(candidateIndex: number): void;
+}
+/**
+ * Helper class for searching for the closest approach between polyfaces.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring FacetLocationDetail).
+ * @internal
+ */
+export declare class TwoTreeSearchHandlerForFacetFacetCloseApproach extends TwoTreeDistanceMinimizationSearchHandler<number> {
+    /** Context for first polyface */
+    contextA: PolyfaceRangeTreeContext;
+    /** Context for second polyface */
+    contextB: PolyfaceRangeTreeContext;
+    /** Search state with current min distance and facet pair */
+    searchState: MinimumValueTester<FacetLocationDetailPair>;
+    /** Whether to include facet interior in search */
+    searchFacetInterior: boolean;
+    /** Constructor
+     * @param contextA captured
+     * @param contextB captured
+     * @param maxDist collect points at no more than this separation distance
+     * @param searchFacetInterior true: search facet interior + boundary; false: just boundary
+    */
+    constructor(contextA: PolyfaceRangeTreeContext, contextB: PolyfaceRangeTreeContext, maxDist?: number, searchFacetInterior?: boolean);
+    /** Return the facets with closest approach */
+    getResult(): FacetLocationDetailPair | undefined;
+    /** Return the collected close approaches (if collecting) */
+    getSavedItems(): FacetLocationDetailPair[] | undefined;
+    /** Get current min distance */
+    getCurrentDistance(): number;
+    /** Compute and test the closest approach between two facets, given their indices. */
+    processAppDataPair(indexA: number, indexB: number): void;
+}
+//# sourceMappingURL=RangeTreeSearchHandlers.d.ts.map

package/lib/cjs/polyface/RangeTree/RangeTreeSearchHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RangeTreeSearchHandlers.d.ts","sourceRoot":"","sources":["../../../../src/polyface/RangeTree/RangeTreeSearchHandlers.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAG/F,OAAO,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAA6B,mBAAmB,EAAE,uBAAuB,EAAgC,MAAM,wBAAwB,CAAC;AAC/I,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,wCAAwC,EAAE,MAAM,iBAAiB,CAAC;AAEpG;;;;GAIG;AACH,qBAAa,6CAA8C,SAAQ,uBAAuB,CAAC,MAAM,CAAC;IAChG,0BAA0B;IACnB,OAAO,EAAE,4BAA4B,CAAC;IAC7C,4BAA4B;IACrB,WAAW,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC/C,kCAAkC;IAC3B,UAAU,EAAE,OAAO,CAAC;IAE3B;;;;;OAKG;gBACgB,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,MAAM;IAQ/F,uCAAuC;IAChC,SAAS,IAAI,mBAAmB,GAAG,SAAS;IASnD,0DAA0D;IACnD,aAAa,IAAI,mBAAmB,EAAE,GAAG,SAAS;IAYzD;;;;OAIG;IACa,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAStD,wEAAwE;IACxD,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;CAK7D;AAED;;;;GAIG;AACH,qBAAa,4DAA6D,SAAQ,wCAAwC,CAAC,MAAM,CAAC;IAChI,sCAAsC;IAC/B,QAAQ,EAAE,4BAA4B,CAAC;IAC9C,uCAAuC;IAChC,QAAQ,EAAE,4BAA4B,CAAC;IAC9C,wDAAwD;IACjD,WAAW,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;IAEhE;;;;;OAKG;gBACgB,QAAQ,EAAE,4BAA4B,EAAE,QAAQ,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,MAAM;IAQnH,0CAA0C;IACnC,SAAS,IAAI,uBAAuB,GAAG,SAAS;IAMvD,4DAA4D;IACrD,aAAa,IAAI,uBAAuB,EAAE,GAAG,SAAS;IAM7D,+BAA+B;IACf,kBAAkB,IAAI,MAAM;IAI5C,6EAA6E;IAC7D,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAczE;AAED;;;;GAIG;AACH,qBAAa,oDAAqD,SAAQ,uBAAuB,CAAC,MAAM,CAAC;IACvG,0BAA0B;IACnB,OAAO,EAAE,4BAA4B,CAAC;IAC7C,4BAA4B;IACrB,WAAW,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;IAC5D,iCAAiC;IAC1B,UAAU,EAAE,OAAO,CAAC;IAE3B;;;;;OAKG;gBACgB,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,MAAM;IAQ/F,uCAAuC;IAChC,SAAS,IAAI,mBAAmB,GAAG,SAAS;IAMnD,0DAA0D;IACnD,aAAa,IAAI,mBAAmB,EAAE,GAAG,SAAS;IAMzD;;;;OAIG;IACa,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAStD,OAAO,CAAC,YAAY,CAAC,CAAgB;IACrC,0EAA0E;IAC1D,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;CAS7D;AAED;;;;GAIG;AACH,qBAAa,4DAA6D,SAAQ,wCAAwC,CAAC,MAAM,CAAC;IAChI,iCAAiC;IAC1B,QAAQ,EAAE,4BAA4B,CAAC;IAC9C,kCAAkC;IAC3B,QAAQ,EAAE,4BAA4B,CAAC;IAC9C,wDAAwD;IACjD,WAAW,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;IAEhE;;;;;OAKG;gBACgB,QAAQ,EAAE,4BAA4B,EAAE,QAAQ,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,MAAM;IAQnH;;;OAGG;IACI,SAAS,IAAI,uBAAuB,GAAG,SAAS;IAMvD,4DAA4D;IACrD,aAAa,IAAI,uBAAuB,EAAE,GAAG,SAAS;IAM7D,+BAA+B;IACf,kBAAkB,IAAI,MAAM;IAI5C,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAgB;IAC7C,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAAgB;IAC7C,uFAAuF;IACvE,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAazE;AAED;;;;GAIG;AACH,qBAAa,gDAAiD,SAAQ,uBAAuB,CAAC,MAAM,CAAC;IACnG,0BAA0B;IACnB,OAAO,EAAE,wBAAwB,CAAC;IACzC,4BAA4B;IACrB,WAAW,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;IAC5D,iCAAiC;IAC1B,UAAU,EAAE,OAAO,CAAC;IAC3B,kDAAkD;IAC3C,mBAAmB,EAAE,OAAO,CAAC;IAEpC;;;;;;OAMG;gBACgB,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,wBAAwB,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,mBAAmB,GAAE,OAAe;IASjI,uCAAuC;IAChC,SAAS,IAAI,mBAAmB,GAAG,SAAS;IAMnD,0DAA0D;IACnD,aAAa,IAAI,mBAAmB,EAAE,GAAG,SAAS;IAMzD;;;;OAIG;IACa,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAStD,wEAAwE;IACxD,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;CAkB7D;AACD;;;;GAIG;AACH,qBAAa,8CAA+C,SAAQ,wCAAwC,CAAC,MAAM,CAAC;IAClH,iCAAiC;IAC1B,QAAQ,EAAE,wBAAwB,CAAC;IAC1C,kCAAkC;IAC3B,QAAQ,EAAE,wBAAwB,CAAC;IAC1C,4DAA4D;IACrD,WAAW,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;IAChE,kDAAkD;IAC3C,mBAAmB,EAAE,OAAO,CAAC;IAEpC;;;;;MAKE;gBACiB,QAAQ,EAAE,wBAAwB,EAAE,QAAQ,EAAE,wBAAwB,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,mBAAmB,GAAE,OAAe;IASjJ,8CAA8C;IACvC,SAAS,IAAI,uBAAuB,GAAG,SAAS;IAMvD,4DAA4D;IACrD,aAAa,IAAI,uBAAuB,EAAE,GAAG,SAAS;IAM7D,+BAA+B;IACf,kBAAkB,IAAI,MAAM;IAI5C,qFAAqF;IACrE,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAkBzE"}

package/lib/cjs/polyface/RangeTree/RangeTreeSearchHandlers.js

@@ -0,0 +1,383 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module RangeSearch
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwoTreeSearchHandlerForFacetFacetCloseApproach = exports.SingleTreeSearchHandlerForClosestPointOnPolyface = exports.TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach = exports.SingleTreeSearchHandlerForClosestPointOnLineString3d = exports.TwoTreeSearchHandlerForPoint3dArrayPoint3dArrayCloseApproach = exports.SingleTreeSearchHandlerForClosestPointInArray = void 0;
+const CurveLocationDetail_1 = require("../../curve/CurveLocationDetail");
+const LineSegment3d_1 = require("../../curve/LineSegment3d");
+const LineString3d_1 = require("../../curve/LineString3d");
+const PolygonOps_1 = require("../../geometry3d/PolygonOps");
+const FacetLocationDetail_1 = require("../FacetLocationDetail");
+const MinimumValueTester_1 = require("./MinimumValueTester");
+const RangeTreeNode_1 = require("./RangeTreeNode");
+/**
+ * Helper class for searching for the closest point in a set of points.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+class SingleTreeSearchHandlerForClosestPointInArray extends RangeTreeNode_1.SingleTreeSearchHandler {
+    /**
+     * Constructor
+     * @param spacePoint cloned
+     * @param context captured
+     * @param maxDist collect points at no more than this distance from spacePoint
+     */
+    constructor(spacePoint, context, maxDist) {
+        super();
+        this.context = context;
+        if (maxDist !== undefined && maxDist < 0)
+            maxDist = undefined;
+        this.searchState = MinimumValueTester_1.MinimumValueTester.create(maxDist);
+        this.spacePoint = spacePoint.clone();
+    }
+    /** Return the current closest point */
+    getResult() {
+        if (this.searchState.minValue !== undefined && this.searchState.itemAtMinValue !== undefined) {
+            const iPoint = this.searchState.itemAtMinValue;
+            const cld = CurveLocationDetail_1.CurveLocationDetail.createCurveFractionPoint(undefined, iPoint, this.context.points[iPoint]);
+            cld.a = this.searchState.minValue;
+            return cld;
+        }
+        return undefined;
+    }
+    /** Return the collected closest points (if collecting) */
+    getSavedItems() {
+        if (this.searchState.savedItems.length === 0)
+            return undefined;
+        const cldArray = [];
+        for (let i = 0; i < this.searchState.savedItems.length; ++i) {
+            const iPoint = this.searchState.savedItems[i];
+            const cld = CurveLocationDetail_1.CurveLocationDetail.createCurveFractionPoint(undefined, iPoint, this.context.points[iPoint]);
+            cld.a = this.searchState.savedValues[i];
+            cldArray.push(cld);
+        }
+        return cldArray;
+    }
+    /**
+     * Return true if appData within the range should be offered to `processAppData`.
+     * @param range range containing items to be tested.
+     * @returns true if the spacePoint is within the range or close enough that a point in the range could be the closest.
+     */
+    isRangeActive(range) {
+        const dMin = range.distanceToPoint(this.spacePoint);
+        if (this.searchState.isNewMinValue(dMin)) {
+            this.context.numRangeTestTrue++;
+            return true;
+        }
+        this.context.numRangeTestFalse++;
+        return false;
+    }
+    /** Test a point indexed in the range tree as candidate for "closest" */
+    processAppData(candidateIndex) {
+        const d = this.spacePoint.distance(this.context.points[candidateIndex]);
+        this.context.numPointTest++;
+        this.searchState.testAndSave(candidateIndex, d);
+    }
+}
+exports.SingleTreeSearchHandlerForClosestPointInArray = SingleTreeSearchHandlerForClosestPointInArray;
+/**
+ * Helper class for searching for the closest approach between sets of points.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+class TwoTreeSearchHandlerForPoint3dArrayPoint3dArrayCloseApproach extends RangeTreeNode_1.TwoTreeDistanceMinimizationSearchHandler {
+    /**
+     * Constructor
+     * @param contextA captured
+     * @param contextB captured
+     * @param maxDist collect points at no more than this separation distance
+     */
+    constructor(contextA, contextB, maxDist) {
+        super();
+        this.contextA = contextA;
+        this.contextB = contextB;
+        if (maxDist !== undefined && maxDist < 0)
+            maxDist = undefined;
+        this.searchState = MinimumValueTester_1.MinimumValueTester.create(maxDist);
+    }
+    /** Return the current closest approach */
+    getResult() {
+        if (this.searchState.minValue !== undefined) {
+            return this.searchState.itemAtMinValue;
+        }
+        return undefined;
+    }
+    /** Return the collected close approaches (if collecting) */
+    getSavedItems() {
+        if (this.searchState.savedItems.length > 0) {
+            return this.searchState.savedItems;
+        }
+        return undefined;
+    }
+    /** Get current min distance */
+    getCurrentDistance() {
+        const d = this.searchState.minValue;
+        return d === undefined ? Number.MAX_VALUE : d;
+    }
+    /** Compute and test the distance between two points, given their indices. */
+    processAppDataPair(indexA, indexB) {
+        this.contextA.numPointTest++;
+        const pointA = this.contextA.points[indexA];
+        const pointB = this.contextB.points[indexB];
+        const d = pointA.distance(pointB);
+        if (this.searchState.isNewMinOrTrigger(d)) {
+            const cldPair = CurveLocationDetail_1.CurveLocationDetailPair.createCapture(CurveLocationDetail_1.CurveLocationDetail.createCurveFractionPoint(undefined, indexA, pointA), CurveLocationDetail_1.CurveLocationDetail.createCurveFractionPoint(undefined, indexB, pointB));
+            cldPair.detailA.a = cldPair.detailB.a = d;
+            this.searchState.testAndSave(cldPair, d);
+        }
+    }
+}
+exports.TwoTreeSearchHandlerForPoint3dArrayPoint3dArrayCloseApproach = TwoTreeSearchHandlerForPoint3dArrayPoint3dArrayCloseApproach;
+/**
+ * Helper class for searching for the closest point in a linestring.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+class SingleTreeSearchHandlerForClosestPointOnLineString3d extends RangeTreeNode_1.SingleTreeSearchHandler {
+    /**
+     * Constructor
+     * @param spacePoint cloned
+     * @param context captured
+     * @param maxDist collect points at no more than this distance from spacePoint
+     */
+    constructor(spacePoint, context, maxDist) {
+        super();
+        this.context = context;
+        if (maxDist !== undefined && maxDist < 0)
+            maxDist = undefined;
+        this.searchState = MinimumValueTester_1.MinimumValueTester.create(maxDist);
+        this.spacePoint = spacePoint.clone();
+    }
+    /** Return the current closest point */
+    getResult() {
+        if (this.searchState.minValue !== undefined && this.searchState.itemAtMinValue !== undefined) {
+            return this.searchState.itemAtMinValue;
+        }
+        return undefined;
+    }
+    /** Return the collected closest points (if collecting) */
+    getSavedItems() {
+        if (this.searchState.savedItems.length > 0) {
+            return this.searchState.savedItems;
+        }
+        return undefined;
+    }
+    /**
+     * Return true if appData within the range should be offered to `processAppData`.
+     * @param range range containing items to be tested.
+     * @returns true if the spacePoint is within the range or close enough that a point in the range could be the closest.
+     */
+    isRangeActive(range) {
+        const dMin = range.distanceToPoint(this.spacePoint);
+        if (this.searchState.isNewMinValue(dMin)) {
+            this.context.numRangeTestTrue++;
+            return true;
+        }
+        this.context.numRangeTestFalse++;
+        return false;
+    }
+    /** Test a segment indexed in the range tree as candidate for "closest" */
+    processAppData(candidateIndex) {
+        const segment = this._workSegment = this.context.lineString.getIndexedSegment(candidateIndex, this._workSegment);
+        if (segment) {
+            const cld = segment.closestPoint(this.spacePoint, false);
+            LineString3d_1.LineString3d.convertLocalToGlobalDetail(cld, candidateIndex, this.context.lineString.numEdges(), this.context.lineString);
+            this.context.numPointTest++;
+            this.searchState.testAndSave(cld, cld.a);
+        }
+    }
+}
+exports.SingleTreeSearchHandlerForClosestPointOnLineString3d = SingleTreeSearchHandlerForClosestPointOnLineString3d;
+/**
+ * Helper class for searching for the closest approach between linestrings.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring CurveLocationDetail).
+ * @internal
+ */
+class TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach extends RangeTreeNode_1.TwoTreeDistanceMinimizationSearchHandler {
+    /**
+     * Constructor
+     * @param contextA captured
+     * @param contextB captured
+     * @param maxDist collect points at no more than this separation distance
+     */
+    constructor(contextA, contextB, maxDist) {
+        super();
+        this.contextA = contextA;
+        this.contextB = contextB;
+        if (maxDist !== undefined && maxDist < 0)
+            maxDist = undefined;
+        this.searchState = MinimumValueTester_1.MinimumValueTester.create(maxDist);
+    }
+    /**
+     * Return the current closest approach.
+     * * Details contain linestring *and* segment data, cf. [[LineString3d.convertLocalToGlobalDetail]]
+     */
+    getResult() {
+        if (this.searchState.minValue !== undefined) {
+            return this.searchState.itemAtMinValue;
+        }
+        return undefined;
+    }
+    /** Return the collected close approaches (if collecting) */
+    getSavedItems() {
+        if (this.searchState.savedItems.length > 0) {
+            return this.searchState.savedItems;
+        }
+        return undefined;
+    }
+    /** Get current min distance */
+    getCurrentDistance() {
+        const d = this.searchState.minValue;
+        return d === undefined ? Number.MAX_VALUE : d;
+    }
+    /** Compute and test the closest approach between two segments, given their indices. */
+    processAppDataPair(indexA, indexB) {
+        this.contextA.numPointTest++;
+        const segA = TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach._workSegmentA =
+            this.contextA.lineString.getIndexedSegment(indexA, TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach._workSegmentA);
+        const segB = TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach._workSegmentB =
+            this.contextB.lineString.getIndexedSegment(indexB, TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach._workSegmentB);
+        const cldPair = LineSegment3d_1.LineSegment3d.closestApproach(segA, false, segB, false);
+        if (cldPair && this.searchState.isNewMinOrTrigger(cldPair.detailA.a)) {
+            LineString3d_1.LineString3d.convertLocalToGlobalDetail(cldPair.detailA, indexA, this.contextA.lineString.numEdges(), this.contextA.lineString);
+            LineString3d_1.LineString3d.convertLocalToGlobalDetail(cldPair.detailB, indexB, this.contextB.lineString.numEdges(), this.contextB.lineString);
+            this.searchState.testAndSave(cldPair, cldPair.detailA.a);
+        }
+    }
+}
+exports.TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach = TwoTreeSearchHandlerForLineString3dLineString3dCloseApproach;
+/**
+ * Helper class for searching for the closest point in a polyface.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring FacetLocationDetail).
+ * @internal
+ */
+class SingleTreeSearchHandlerForClosestPointOnPolyface extends RangeTreeNode_1.SingleTreeSearchHandler {
+    /**
+     * Constructor
+     * @param spacePoint cloned
+     * @param context captured
+     * @param maxDist collect points at no more than this distance from spacePoint
+     * @param searchFacetInterior true: search facet interior + boundary; false: just boundary
+     */
+    constructor(spacePoint, context, maxDist, searchFacetInterior = false) {
+        super();
+        this.context = context;
+        if (maxDist !== undefined && maxDist < 0)
+            maxDist = undefined;
+        this.searchState = MinimumValueTester_1.MinimumValueTester.create(maxDist);
+        this.spacePoint = spacePoint.clone();
+        this.searchFacetInterior = searchFacetInterior;
+    }
+    /** Return the current closest point */
+    getResult() {
+        if (this.searchState.minValue !== undefined && this.searchState.itemAtMinValue !== undefined) {
+            return this.searchState.itemAtMinValue;
+        }
+        return undefined;
+    }
+    /** Return the collected closest points (if collecting) */
+    getSavedItems() {
+        if (this.searchState.savedItems.length > 0) {
+            return this.searchState.savedItems;
+        }
+        return undefined;
+    }
+    /**
+     * Return true if appData within the range should be offered to `processAppData`.
+     * @param range range containing items to be tested.
+     * @returns true if the spacePoint is within the range or close enough that a point in the range could be the closest.
+     */
+    isRangeActive(range) {
+        const dMin = range.distanceToPoint(this.spacePoint);
+        if (this.searchState.isNewMinValue(dMin)) {
+            this.context.numRangeTestTrue++;
+            return true;
+        }
+        this.context.numRangeTestFalse++;
+        return false;
+    }
+    /** Test a facet indexed in the range tree as candidate for "closest" */
+    processAppData(candidateIndex) {
+        this.context.visitor.setNumWrap(0); // so edgeCount === pointCount; closure point unnecessary for closestPoint[OnBoundary]
+        if (this.context.visitor.moveToReadIndex(candidateIndex)) {
+            let pld;
+            if (this.searchFacetInterior)
+                pld = PolygonOps_1.PolygonOps.closestPoint(this.context.visitor.point, this.spacePoint);
+            else
+                pld = PolygonOps_1.PolygonOps.closestPointOnBoundary(this.context.visitor.point, this.spacePoint);
+            this.context.numFacetTest++;
+            if (pld && this.searchState.isNewMinOrTrigger(pld.a)) {
+                const edgeCount = this.context.visitor.pointCount;
+                const fld = this.context.convexFacets
+                    ? FacetLocationDetail_1.ConvexFacetLocationDetail.createCapture(this.context.visitor.currentReadIndex(), edgeCount, pld)
+                    : FacetLocationDetail_1.NonConvexFacetLocationDetail.createCapture(this.context.visitor.currentReadIndex(), edgeCount, pld);
+                this.searchState.testAndSave(fld, pld.a);
+            }
+        }
+    }
+}
+exports.SingleTreeSearchHandlerForClosestPointOnPolyface = SingleTreeSearchHandlerForClosestPointOnPolyface;
+/**
+ * Helper class for searching for the closest approach between polyfaces.
+ * * Future optimization: avoid sqrt by using squared distance throughout (would require refactoring FacetLocationDetail).
+ * @internal
+ */
+class TwoTreeSearchHandlerForFacetFacetCloseApproach extends RangeTreeNode_1.TwoTreeDistanceMinimizationSearchHandler {
+    /** Constructor
+     * @param contextA captured
+     * @param contextB captured
+     * @param maxDist collect points at no more than this separation distance
+     * @param searchFacetInterior true: search facet interior + boundary; false: just boundary
+    */
+    constructor(contextA, contextB, maxDist, searchFacetInterior = false) {
+        super();
+        this.contextA = contextA;
+        this.contextB = contextB;
+        if (maxDist !== undefined && maxDist < 0)
+            maxDist = undefined;
+        this.searchState = MinimumValueTester_1.MinimumValueTester.create(maxDist);
+        this.searchFacetInterior = searchFacetInterior && contextA.convexFacets && contextB.convexFacets;
+    }
+    /** Return the facets with closest approach */
+    getResult() {
+        if (this.searchState.minValue !== undefined) {
+            return this.searchState.itemAtMinValue;
+        }
+        return undefined;
+    }
+    /** Return the collected close approaches (if collecting) */
+    getSavedItems() {
+        if (this.searchState.savedItems.length > 0) {
+            return this.searchState.savedItems;
+        }
+        return undefined;
+    }
+    /** Get current min distance */
+    getCurrentDistance() {
+        const d = this.searchState.minValue;
+        return d === undefined ? Number.MAX_VALUE : d;
+    }
+    /** Compute and test the closest approach between two facets, given their indices. */
+    processAppDataPair(indexA, indexB) {
+        this.contextA.visitor.setNumWrap(1); // closed polygons are more efficient for PolygonOps.closestApproach
+        this.contextB.visitor.setNumWrap(1);
+        if (this.contextA.visitor.moveToReadIndex(indexA) && this.contextB.visitor.moveToReadIndex(indexB)) {
+            // ASSUME: not worth sending in maxDist here...
+            const pldPair = PolygonOps_1.PolygonOps.closestApproach(this.contextA.visitor.point, this.contextB.visitor.point, undefined, this.searchFacetInterior);
+            this.contextA.numFacetTest++;
+            if (pldPair && this.searchState.isNewMinOrTrigger(pldPair.detailA.a)) {
+                const edgeCountA = this.contextA.visitor.pointCount - 1;
+                const edgeCountB = this.contextB.visitor.pointCount - 1;
+                const fldPair = FacetLocationDetail_1.FacetLocationDetailPair.create(this.contextA.convexFacets ? FacetLocationDetail_1.ConvexFacetLocationDetail.createCapture(indexA, edgeCountA, pldPair.detailA) : FacetLocationDetail_1.NonConvexFacetLocationDetail.createCapture(indexA, edgeCountA, pldPair.detailA), this.contextB.convexFacets ? FacetLocationDetail_1.ConvexFacetLocationDetail.createCapture(indexB, edgeCountB, pldPair.detailB) : FacetLocationDetail_1.NonConvexFacetLocationDetail.createCapture(indexB, edgeCountB, pldPair.detailB));
+                this.searchState.testAndSave(fldPair, fldPair.detailA.a);
+            }
+        }
+    }
+}
+exports.TwoTreeSearchHandlerForFacetFacetCloseApproach = TwoTreeSearchHandlerForFacetFacetCloseApproach;
+//# sourceMappingURL=RangeTreeSearchHandlers.js.map