@itwin/editor-frontend 3.0.0-dev.136 → 3.0.0-dev.141

package/lib/cjs/SketchTools.js

@@ -236,6 +236,7 @@ class CreateOrContinuePathTool extends CreateElementTool_1.CreateElementTool {
             switch (curve.curvePrimitiveType) {
                 case "arc":
                 case "bsplineCurve":
+                case "interpolationCurve":
                     break;
                 default:
                     return;
@@ -270,6 +271,12 @@ class CreateOrContinuePathTool extends CreateElementTool_1.CreateElementTool {
                 builder.addPointString(poles);
                 break;
             }
+            case "interpolationCurve": {
+                const fitCurve = curve;
+                builder.setSymbology(context.viewport.getContrastToBackgroundColor(), core_common_1.ColorDef.black, 5);
+                builder.addPointString(fitCurve.options.fitPoints); // deep copy shoulnd't be necessary...
+                break;
+            }
             default:
                 break;
         }
@@ -557,11 +564,17 @@ class CreateOrContinuePathTool extends CreateElementTool_1.CreateElementTool {
         await this.updateCurveAndContinuationData(ev, false, phase);
         return true;
     }
+    async cancelPoint(_ev) { return true; }
     async onDataButtonDown(ev) {
         if (!await this.acceptPoint(ev))
             return core_frontend_1.EventHandled.Yes;
         return super.onDataButtonDown(ev);
     }
+    async onResetButtonUp(ev) {
+        if (!await this.cancelPoint(ev))
+            return core_frontend_1.EventHandled.Yes;
+        return super.onResetButtonUp(ev);
+    }
     async onUndoPreviousStep() {
         if (0 === this.accepted.length)
             return false;
@@ -621,13 +634,13 @@ class CreateLineStringTool extends CreateOrContinuePathTool {
         const pts = (isDynamics ? [...this.accepted, ev.point] : this.accepted);
         return core_geometry_1.LineString3d.create(pts);
     }
-    async onResetButtonUp(ev) {
+    async cancelPoint(ev) {
         // NOTE: Starting another tool will not create element...require reset or closure...
         if (this.isComplete(ev)) {
             await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineEnd);
             await this.createElement();
         }
-        return super.onResetButtonUp(ev);
+        return true;
     }
     async onRestartTool() {
         const tool = new CreateLineStringTool();
@@ -1195,13 +1208,13 @@ class CreateCircleTool extends CreateOrContinuePathTool {
         vector90.scaleToLength(radius, vector90);
         return core_geometry_1.Arc3d.create(center, vector0, vector90);
     }
-    async onResetButtonUp(ev) {
+    async cancelPoint(_ev) {
         if (CircleMethod.Center === this.method && this.useRadius) {
             // Exit instead of restarting to avoid having circle "stuck" on cursor...
             await this.exitTool();
-            return core_frontend_1.EventHandled.Yes;
+            return false;
         }
-        return super.onResetButtonUp(ev);
+        return true;
     }
     syncToolSettingsRadius() {
         if (this.useRadius)
@@ -1574,6 +1587,13 @@ var BCurveMethod;
 })(BCurveMethod = exports.BCurveMethod || (exports.BCurveMethod = {}));
 /** @alpha Creates a bspline curve by poles or through points. Uses model and category from ToolAdmin.ActiveSettings. */
 class CreateBCurveTool extends CreateOrContinuePathTool {
+    constructor() {
+        super(...arguments);
+        this._isPhysicallyClosedOrComplete = false;
+        this._tangentPhase = CreateCurvePhase.DefineOther;
+    }
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 3; } // method, order, tangents...
     get wantPickableDynamics() { return true; } // Allow snapping to control polygon or through points...
     get showCurveConstructions() { return true; } // Display control polygon or through points...
     provideToolAssistance(_mainInstrText, _additionalInstr) {
@@ -1612,43 +1632,93 @@ class CreateBCurveTool extends CreateOrContinuePathTool {
     set order(value) { this.orderProperty.value = value; }
     get minOrder() { return 2; }
     get maxOrder() { return 16; }
+    get tangentsProperty() {
+        if (!this._tangentsProperty)
+            this._tangentsProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("bcurveTangents", EditTool_1.EditTools.translate("CreateBCurve.Label.Tangents")), false);
+        return this._tangentsProperty;
+    }
+    get tangents() { return this.tangentsProperty.value; }
+    set tangents(value) { this.tangentsProperty.value = value; }
     get wantClosure() {
         // A bcurve can support physical closure when creating a new path...
         return this.allowClosure;
     }
+    get requiredPointCount() {
+        if (BCurveMethod.ThroughPoints === this.method)
+            return 3; // Interpolation curve is always order 4 with 3 point minimum...
+        return this.order;
+    }
+    get createCurvePhase() {
+        if (CreateCurvePhase.DefineOther !== this._tangentPhase)
+            return CreateCurvePhase.DefineOther;
+        return super.createCurvePhase;
+    }
     isComplete(ev) {
         // Accept on reset with sufficient points...
         if (core_frontend_1.BeButton.Reset === ev.button)
-            return (this.accepted.length >= this.order);
+            return (this.accepted.length >= this.requiredPointCount);
         // Allow data to complete on physical closure...
-        return this.isClosed;
+        return this.isClosed || this._isPhysicallyClosedOrComplete;
+    }
+    showConstructionGraphics(ev, context) {
+        if (CreateCurvePhase.DefineOther !== this._tangentPhase && this.current) {
+            const fitCurve = this.current;
+            const builder = context.createGraphic({ type: core_frontend_1.GraphicType.WorldOverlay });
+            const color = context.viewport.getContrastToBackgroundColor();
+            builder.setSymbology(color, core_common_1.ColorDef.black, 1, core_common_1.LinePixels.Code2);
+            builder.addLineString([ev.point, fitCurve.options.fitPoints[CreateCurvePhase.DefineStart === this._tangentPhase ? 0 : fitCurve.options.fitPoints.length - 1]]);
+            builder.setSymbology(color, core_common_1.ColorDef.black, 8);
+            builder.addPointString([ev.point]);
+            context.addGraphic(builder.finish());
+        }
+        return super.showConstructionGraphics(ev, context);
     }
     createNewCurvePrimitive(ev, isDynamics) {
+        if (CreateCurvePhase.DefineOther !== this._tangentPhase && this.current) {
+            const fitCurve = this.current;
+            if (CreateCurvePhase.DefineStart === this._tangentPhase) {
+                const tangentS = core_geometry_1.Vector3d.createStartEnd(ev.point, fitCurve.options.fitPoints[0]);
+                if (tangentS.magnitude() > core_geometry_1.Geometry.smallMetricDistance)
+                    fitCurve.options.startTangent = tangentS;
+            }
+            else {
+                const tangentE = core_geometry_1.Vector3d.createStartEnd(ev.point, fitCurve.options.fitPoints[fitCurve.options.fitPoints.length - 1]);
+                if (tangentE.magnitude() > core_geometry_1.Geometry.smallMetricDistance)
+                    fitCurve.options.endTangent = tangentE;
+            }
+            return fitCurve;
+        }
         // Don't include current point if it's the same as the last accepted point, want dynamics to show an accurate preview of what reset will accept...
         const includeCurrPt = (isDynamics && (0 === this.accepted.length || !ev.point.isAlmostEqual(this.accepted[this.accepted.length - 1])));
         const pts = (includeCurrPt ? [...this.accepted, ev.point] : this.accepted);
-        const numRequired = this.order;
+        const numRequired = this.requiredPointCount;
         if (pts.length < numRequired) {
             // Create point/linestring construction geometry to support join...
             this.isConstruction = true;
             return core_geometry_1.LineString3d.create(1 === pts.length ? [pts[0], pts[0]] : pts);
         }
-        // TODO: Support physical closure by creating closed/rational bcurve...
+        // Create periodic-looking curve on physical closure with sufficient points even when not creating a loop/surface...
+        this._isPhysicallyClosedOrComplete = (undefined === this.continuationData && pts[0].isAlmostEqual(pts[pts.length - 1]));
+        // TODO: Support physical closure for pole construction...
         if (BCurveMethod.ControlPoints === this.method)
             return core_geometry_1.BSplineCurve3d.createUniformKnots(pts, this.order);
-        // TODO: InterpolationCurve3d, set end tangents using continuation curve...self-closure, etc.
-        return core_geometry_1.BSplineCurveOps.createThroughPoints(pts, this.order);
-    }
-    addConstructionGraphics(curve, showCurve, context) {
-        // TODO: Need proper Interpolation curve class to extract/show through points...
-        if (BCurveMethod.ThroughPoints === this.method && !showCurve && 0 !== this.accepted.length) {
-            const builder = context.createGraphic({ type: core_frontend_1.GraphicType.WorldOverlay });
-            builder.setSymbology(context.viewport.getContrastToBackgroundColor(), core_common_1.ColorDef.black, 5);
-            builder.addPointString(this.accepted);
-            context.addGraphic(builder.finish());
-            return;
+        const interpProps = { fitPoints: pts, closed: this._isPhysicallyClosedOrComplete, isChordLenKnots: 1, isColinearTangents: 1 };
+        // Create interpolation curve tangent to continuation curve...
+        if (undefined !== this.continuationData && this.tangents) {
+            const tangentS = this.continuationData.path.children[0].fractionToPointAndUnitTangent(0.0);
+            const tangentE = this.continuationData.path.children[this.continuationData.path.children.length - 1].fractionToPointAndUnitTangent(1.0);
+            if (pts[0].isAlmostEqual(tangentS.origin))
+                interpProps.startTangent = tangentS.direction.scale(-1);
+            else if (pts[0].isAlmostEqual(tangentE.origin))
+                interpProps.startTangent = tangentE.direction;
+            if (pts[pts.length - 1].isAlmostEqual(tangentS.origin))
+                interpProps.endTangent = tangentS.direction.scale(-1);
+            else if (pts[pts.length - 1].isAlmostEqual(tangentE.origin))
+                interpProps.endTangent = tangentE.direction;
+            this._isPhysicallyClosedOrComplete = (undefined !== interpProps.startTangent && undefined !== interpProps.endTangent);
         }
-        return super.addConstructionGraphics(curve, showCurve, context);
+        const interpOpts = core_geometry_1.InterpolationCurve3dOptions.create(interpProps);
+        return core_geometry_1.InterpolationCurve3d.createCapture(interpOpts);
     }
     getSnapGeometry() {
         // Only snap to through points...
@@ -1656,13 +1726,46 @@ class CreateBCurveTool extends CreateOrContinuePathTool {
             return (this.accepted.length > 1 ? core_geometry_1.PointString3d.create(this.accepted) : undefined);
         return super.getSnapGeometry();
     }
-    async onResetButtonUp(ev) {
+    async acceptPoint(ev) {
+        switch (this._tangentPhase) {
+            case CreateCurvePhase.DefineOther:
+                return super.acceptPoint(ev);
+            case CreateCurvePhase.DefineStart:
+                this._tangentPhase = CreateCurvePhase.DefineEnd;
+                break;
+            case CreateCurvePhase.DefineEnd:
+                this._isPhysicallyClosedOrComplete = true;
+                break;
+        }
+        await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineOther);
+        return true;
+    }
+    async cancelPoint(ev) {
         // NOTE: Starting another tool will not create element...require reset or closure...
         if (this.isComplete(ev)) {
+            if (BCurveMethod.ThroughPoints === this.method && this.tangents && this.current) {
+                const fitCurve = this.current;
+                switch (this._tangentPhase) {
+                    case CreateCurvePhase.DefineOther:
+                        await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineEnd);
+                        this._tangentPhase = (undefined === fitCurve.options.startTangent ? CreateCurvePhase.DefineStart : CreateCurvePhase.DefineEnd);
+                        core_frontend_1.IModelApp.toolAdmin.updateDynamics();
+                        return false;
+                    case CreateCurvePhase.DefineStart:
+                        fitCurve.options.startTangent = undefined; // Not accepted, compute default start tangent...
+                        this._tangentPhase = CreateCurvePhase.DefineEnd;
+                        core_frontend_1.IModelApp.toolAdmin.updateDynamics();
+                        return false;
+                    case CreateCurvePhase.DefineEnd:
+                        fitCurve.options.endTangent = undefined; // Not accepted, compute default end tangent...
+                        await this.createElement();
+                        return true;
+                }
+            }
             await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineEnd);
             await this.createElement();
         }
-        return super.onResetButtonUp(ev);
+        return true;
     }
     syncOrderState() {
         this.orderProperty.displayValue = this.orderProperty.description.format(this.order);
@@ -1684,12 +1787,20 @@ class CreateBCurveTool extends CreateOrContinuePathTool {
             core_frontend_1.IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.orderProperty.item);
             return true;
         }
+        else if (updatedValue.propertyName === this.tangentsProperty.name) {
+            this.tangents = updatedValue.value.value;
+            core_frontend_1.IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.tangentsProperty.item);
+            return true;
+        }
         return false;
     }
     supplyToolSettingsProperties() {
         const toolSettings = new Array();
         toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.orderProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }));
+        if (BCurveMethod.ThroughPoints === this.method)
+            toolSettings.push(this.tangentsProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
+        else
+            toolSettings.push(this.orderProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }));
         return toolSettings;
     }
     async onRestartTool() {
@@ -1707,15 +1818,20 @@ class CreateBCurveTool extends CreateOrContinuePathTool {
         const orderValue = core_frontend_1.IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.orderProperty.name);
         if (undefined !== orderValue)
             this.orderProperty.dialogItemValue = orderValue;
+        const tangentsValue = core_frontend_1.IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.tangentsProperty.name);
+        if (undefined !== tangentsValue)
+            this.tangentsProperty.dialogItemValue = tangentsValue;
         return true;
     }
     /** The keyin takes the following arguments, all of which are optional:
      *  - `method=0|1` How bcurve will be defined. 0 for control points, 1 for through points.
      *  - `order=number` bcurve order from 2 to 16.
+     *  - 'tangents=0|1 Whether to specify start/end tangents for through points construction.
      */
     async parseAndRun(...inputArgs) {
         let bcurveMethod;
         let bcurveOrder;
+        let bcurveTangents;
         for (const arg of inputArgs) {
             const parts = arg.split("=");
             if (2 !== parts.length)
@@ -1739,12 +1855,18 @@ class CreateBCurveTool extends CreateOrContinuePathTool {
                     bcurveOrder = order;
                 }
             }
+            else if (parts[0].toLowerCase().startsWith("ta")) {
+                const tangents = Number.parseInt(parts[1], 10);
+                bcurveTangents = (0 !== tangents);
+            }
         }
         // Update current session values so keyin args are picked up for tool settings/restart...
         if (undefined !== bcurveMethod)
             core_frontend_1.IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.methodProperty.name, value: { value: bcurveMethod } });
         if (undefined !== bcurveOrder)
             core_frontend_1.IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.orderProperty.name, value: { value: bcurveOrder } });
+        if (undefined !== bcurveTangents)
+            core_frontend_1.IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.tangentsProperty.name, value: { value: bcurveTangents } });
         return this.run();
     }
 }