@design-core/core 0.0.1 → 0.0.3

package/core/tools/rotate.js

@@ -1,22 +1,41 @@
-import {Strings} from '../lib/strings.js';
-import {Tool} from './tool.js';
-import {Utils} from '../lib/utils.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
-
-import {DesignCore} from '../designCore.js';
-
-
+import { Strings } from '../lib/strings.js';
+import { Tool } from './tool.js';
+import { Utils } from '../lib/utils.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
+import { Point } from '../entities/point.js';
+import { UpdateState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Rotate Command Class
+ * @extends Tool
+ */
 export class Rotate extends Tool {
+  /** Create a Rotate command */
   constructor() {
     super();
+    this.baseAngle = 0;
+    this.basePoint = null;
   }
 
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
   static register() {
-    const command = {command: 'Rotate', shortcut: 'RO', type: 'Tool'};
+    const command = { command: 'Rotate', shortcut: 'RO', type: 'Tool' };
     return command;
   }
 
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.SELECTIONSET, [Input.Type.SELECTIONSET]);
@@ -26,87 +45,103 @@ export class Rotate extends Tool {
       }
 
       const op2 = new PromptOptions(Strings.Input.BASEPOINT, [Input.Type.POINT]);
-      const pt1 = await DesignCore.Scene.inputManager.requestInput(op2);
-      this.points.push(pt1);
-
-      const op3 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
-      const pt2 = await DesignCore.Scene.inputManager.requestInput(op3);
-      this.points.push(pt2);
-
-      const op4 = new PromptOptions(Strings.Input.ROTATION, [Input.Type.POINT, Input.Type.NUMBER]);
-      const pt3 = await DesignCore.Scene.inputManager.requestInput(op4);
-      if (Input.getType(pt3) === Input.Type.POINT) {
-        this.points.push(pt3);
-      } else if (Input.getType(pt3) === Input.Type.NUMBER) {
-        const basePoint = this.points.at(0);
-        const startPoint = this.points.at(1);
-        const angle = Utils.degrees2radians(pt3);
-        const point = startPoint.rotate(basePoint, angle);
-        this.points.push(point);
+      const input1 = await DesignCore.Scene.inputManager.requestInput(op2);
+      if (input1 === undefined) return;
+      this.points.push(input1);
+
+      while (this.points.length < 2) {
+        const op3 = new PromptOptions(Strings.Input.ROTATION, [Input.Type.POINT, Input.Type.NUMBER], ['Reference']);
+        const input2 = await DesignCore.Scene.inputManager.requestInput(op3);
+        if (input2 === undefined) return;
+
+        if (Input.getType(input2) === Input.Type.STRING) {
+          // set the base angle to null to prevent the preview
+          this.baseAngle = null;
+          const op4 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
+          const refBase = await DesignCore.Scene.inputManager.requestInput(op4);
+          if (refBase === undefined) return;
+          // set the base point to the reference start point
+          this.basePoint = refBase;
+
+          const op5 = new PromptOptions(Strings.Input.END, [Input.Type.POINT]);
+          const refEnd = await DesignCore.Scene.inputManager.requestInput(op5);
+          if (refEnd === undefined) return;
+          // set the base angle to the reference
+          this.baseAngle = refBase.angle(refEnd);
+          // set the base point to null
+          this.basePoint = null;
+        } else if (Input.getType(input2) === Input.Type.NUMBER) {
+          const basePoint = this.points.at(0);
+          const angle = Utils.degrees2radians(input2);
+          const point = basePoint.project(angle, 100);
+          this.points.push(point);
+        } else if (Input.getType(input2) === Input.Type.POINT) {
+          this.points.push(input2);
+        }
       }
 
-
       DesignCore.Scene.inputManager.executeCommand();
     } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
   }
 
+  /**
+   * Preview the command during execution
+   */
   preview() {
     const mousePoint = DesignCore.Mouse.pointOnScene();
 
-    if (this.points.length >= 1) {
+    if (this.points.length >= 1 && this.baseAngle !== null || this.basePoint !== null) {
       // Draw a line
-      const points = [this.points.at(0), mousePoint];
-
-      DesignCore.Scene.createTempItem('Line', {points: points});
+      const center = this.basePoint === null ? this.points.at(0) : this.basePoint;
+      const points = [center, mousePoint];
+      DesignCore.Scene.tempEntities.create('Line', { points: points });
     }
 
-    if (this.points.length >= 2) {
-      const A = this.points[0].x - this.points[1].x;
-      const O = this.points[0].y - this.points[1].y;
-
-      const A1 = this.points[0].x - mousePoint.x;
-      const O1 = this.points[0].y - mousePoint.y;
-
-      const ang1 = Math.atan2(O, A);
-      const ang2 = Math.atan2(O1, A1);
-
-      const theta = ang2 - ang1;
-
-      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        for (let j = 0; j <DesignCore.Scene.selectionManager.selectedItems[i].points.length; j++) {
-          const x = this.points[0].x + (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x - this.points[0].x) * Math.cos(theta) - (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y - this.points[0].y) * Math.sin(theta);
-          const y = this.points[0].y + (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x - this.points[0].x) * Math.sin(theta) + (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y - this.points[0].y) * Math.cos(theta);
-
-          DesignCore.Scene.selectionManager.selectedItems[i].points[j].x = x;
-          DesignCore.Scene.selectionManager.selectedItems[i].points[j].y = y;
-        }
+    if (this.points.length >= 1) {
+      const ang = this.points[0].angle(mousePoint);
+      const theta = this.baseAngle === null ? 0 : ang - this.baseAngle;
+      const center = this.points[0];
+
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
+        const item = DesignCore.Scene.selectionManager.selectedItems[i];
+        // get the original points from the scene entities
+        const entityIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
+        const originalItem = DesignCore.Scene.entities.get(entityIndex);
+        item.setProperty('points', this.getRotatedPoints(originalItem.points, center, theta));
       }
     }
   };
 
-
+  /**
+   * Perform the command
+   */
   action() {
-    const A = this.points[0].x - this.points[1].x;
-    const O = this.points[0].y - this.points[1].y;
-
-    const A1 = this.points[0].x - this.points[2].x;
-    const O1 = this.points[0].y - this.points[2].y;
-
-    const ang1 = Math.atan2(O, A);
-    const ang2 = Math.atan2(O1, A1);
+    const ang = this.points[0].angle(this.points[1]);
+    const theta = ang - this.baseAngle;
+    const center = this.points[0];
 
-    const theta = ang2 - ang1;
+    const stateChanges = [];
 
-    for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-      for (let j = 0; j <DesignCore.Scene.selectionManager.selectedItems[i].points.length; j++) {
-        const x = this.points[0].x + (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x - this.points[0].x) * Math.cos(theta) - (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y - this.points[0].y) * Math.sin(theta);
-        const y = this.points[0].y + (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x - this.points[0].x) * Math.sin(theta) + (DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y - this.points[0].y) * Math.cos(theta);
-
-        DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].x = x;
-        DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]].points[j].y = y;
-      }
+    for (let index = 0; index < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; index++) {
+      const item = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[index]);
+      const stateChange = new UpdateState(item, { points: this.getRotatedPoints(item.points, center, theta) });
+      stateChanges.push(stateChange);
     }
+
+    DesignCore.Scene.commit(stateChanges);
   };
+
+  /**
+ * Get rotated points
+ * @param {Array} points
+ * @param {Point} center
+ * @param {Point} theta
+ * @return {Array} rotatedPoints
+ */
+  getRotatedPoints(points, center, theta) {
+    const rotatedPoints = points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).rotate(center, theta));
+    return rotatedPoints;
+  }
 }

package/core/tools/scale.js

@@ -0,0 +1,166 @@
+import { Strings } from '../lib/strings.js';
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
+import { Point } from '../entities/point.js';
+import { UpdateState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Scale Command Class
+ * @extends Tool
+ */
+export class Scale extends Tool {
+  /** Create a Scale command */
+  constructor() {
+    super();
+    this.scaleFactor = 1;
+    this.referencePoint = null;
+    this.referenceLength = null;
+  }
+
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
+  static register() {
+    const command = { command: 'Scale', shortcut: 'SC' }; // , type: 'Tool' };
+    return command;
+  }
+
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
+  async execute() {
+    try {
+      const op = new PromptOptions(Strings.Input.SELECTIONSET, [Input.Type.SELECTIONSET]);
+
+      if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
+        await DesignCore.Scene.inputManager.requestInput(op);
+      }
+
+      const op2 = new PromptOptions(Strings.Input.BASEPOINT, [Input.Type.POINT]);
+      const basePoint = await DesignCore.Scene.inputManager.requestInput(op2);
+      if (basePoint === undefined) return;
+      this.points.push(basePoint);
+
+      while (this.points.length < 2) {
+        const op3 = new PromptOptions(Strings.Input.SCALEFACTOR, [Input.Type.POINT, Input.Type.NUMBER], ['Reference']);
+        const input = await DesignCore.Scene.inputManager.requestInput(op3);
+        if (input === undefined) return;
+
+        if (Input.getType(input) === Input.Type.STRING) {
+          // Reference workflow: define a reference length then a new length
+          // set referencePoint temporarily to prevent preview scaling
+          this.referencePoint = basePoint;
+
+          const op4 = new PromptOptions(Strings.Input.REFERENCELENGTH, [Input.Type.POINT, Input.Type.NUMBER]);
+          const refInput = await DesignCore.Scene.inputManager.requestInput(op4);
+          if (refInput === undefined) return;
+
+          let referenceLength;
+          if (Input.getType(refInput) === Input.Type.NUMBER) {
+            referenceLength = refInput;
+            this.referencePoint = null;
+          } else {
+            // refInput is a point — store it and ask for second point
+            this.referencePoint = refInput;
+            const op5 = new PromptOptions(Strings.Input.END, [Input.Type.POINT]);
+            const refEnd = await DesignCore.Scene.inputManager.requestInput(op5);
+            if (refEnd === undefined) return;
+            referenceLength = refInput.distance(refEnd);
+            this.referencePoint = null;
+          }
+
+          if (referenceLength === 0) return;
+
+          this.referenceLength = referenceLength;
+          const op6 = new PromptOptions(Strings.Input.NEWLENGTH, [Input.Type.POINT, Input.Type.NUMBER]);
+          const newInput = await DesignCore.Scene.inputManager.requestInput(op6);
+          if (newInput === undefined) return;
+
+          let newLength;
+          if (Input.getType(newInput) === Input.Type.NUMBER) {
+            newLength = newInput;
+          } else {
+            newLength = basePoint.distance(newInput);
+          }
+
+          this.scaleFactor = newLength / referenceLength;
+          // Push a dummy second point to satisfy the loop condition
+          this.points.push(basePoint);
+        } else if (Input.getType(input) === Input.Type.NUMBER) {
+          this.scaleFactor = input;
+          this.points.push(basePoint);
+        } else if (Input.getType(input) === Input.Type.POINT) {
+          // Scale factor is the distance from the base point to the input point
+          const distance = basePoint.distance(input);
+          this.scaleFactor = distance;
+          this.points.push(input);
+        }
+      }
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
+      Logging.instance.error(`${this.type} - ${err}`);
+    }
+  }
+
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    const mousePoint = DesignCore.Mouse.pointOnScene();
+
+    if (this.points.length >= 1 && this.referencePoint === null) {
+      // Draw a line from base point to mouse
+      const points = [this.points[0], mousePoint];
+      DesignCore.Scene.tempEntities.create('Line', { points: points });
+
+      const base = this.points[0];
+      const distance = base.distance(mousePoint);
+      if (distance === 0) return;
+
+      const factor = this.referenceLength !== null ? distance / this.referenceLength : distance;
+
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectedItems.length; i++) {
+        const item = DesignCore.Scene.selectionManager.selectedItems[i];
+        const entityIndex = DesignCore.Scene.selectionManager.selectionSet.selectionSet[i];
+        const originalItem = DesignCore.Scene.entities.get(entityIndex);
+        item.setProperty('points', this.getScaledPoints(originalItem.points, base, factor));
+      }
+    }
+  }
+
+  /**
+   * Perform the command
+   */
+  action() {
+    const base = this.points[0];
+    const stateChanges = [];
+
+    for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+      const item = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+      const stateChange = new UpdateState(item, { points: this.getScaledPoints(item.points, base, this.scaleFactor) });
+      stateChanges.push(stateChange);
+    }
+
+    DesignCore.Scene.commit(stateChanges);
+  }
+
+  /**
+   * Get scaled points about a base point
+   * @param {Array} points
+   * @param {Point} base
+   * @param {number} factor
+   * @return {Array} scaledPoints
+   */
+  getScaledPoints(points, base, factor) {
+    return points.map((p) => new Point(p.x, p.y, p.bulge, p.sequence).scaleFrom(base, factor));
+  }
+}

package/core/tools/tool.js

@@ -1,4 +1,8 @@
+/**
+ * Tool Class
+ */
 export class Tool {
+  /** Create a Tool command */
   constructor() {
     Object.defineProperty(this, 'type', {
       value: this.constructor.name,
@@ -11,12 +15,18 @@ export class Tool {
     });
   }
 
-  action() {
-    // action function to be overidden by implementation
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    // preview function to be overridden by implementation
   };
 
-  preview() {
-    // preview function to be overidden by implementation
+  /**
+   * Perform the command
+   */
+  action() {
+    // action function to be overridden by implementation
   };
 }
 

package/core/tools/trim.js

@@ -1,72 +1,111 @@
-import {Intersection} from '../lib/intersect.js';
-import {Strings} from '../lib/strings.js';
-import {Tool} from './tool.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
+import { Intersection } from '../lib/intersect.js';
+import { Strings } from '../lib/strings.js';
+import { Tool } from './tool.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
 
-import {DesignCore} from '../designCore.js';
+import { DesignCore } from '../designCore.js';
 
+/**
+ * Trim Command Class
+ * @extends Tool
+ */
 export class Trim extends Tool {
+  /** Create a Trim command */
   constructor() {
     super();
-    this.selectedIndex;
+    this.selectedItem = null;
+    this.selectedBoundaryItems = [];
   }
 
+  /**
+   * Register the command
+   * @return {Object}
+   * command = name of the command
+   * shortcut = shortcut for the command
+   * type = type to group command in toolbars (omitted if not shown)
+   */
   static register() {
-    const command = {command: 'Trim', shortcut: 'TR', type: 'Tool'};
+    const command = { command: 'Trim', shortcut: 'TR', type: 'Tool' };
     return command;
   }
 
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to perform the command
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.BOUNDARY, [Input.Type.SELECTIONSET]);
 
       if (!DesignCore.Scene.selectionManager.selectionSet.selectionSet.length) {
-        await DesignCore.Scene.inputManager.requestInput(op);
+        const boundary = await DesignCore.Scene.inputManager.requestInput(op);
+        if (boundary === undefined) return;
+      }
+
+      // add all selected items to boundary items
+      for (let i = 0; i < DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
+        const boundaryItem = DesignCore.Scene.entities.get(DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]);
+        this.selectedBoundaryItems.push(boundaryItem);
       }
 
       const op2 = new PromptOptions(Strings.Input.SELECT, [Input.Type.SINGLESELECTION]);
       while (true) {
         const selection = await DesignCore.Scene.inputManager.requestInput(op2);
-        this.selectedIndex = selection.selectedItemIndex;
+        if (selection === undefined) break;
+        this.selectedItem = DesignCore.Scene.entities.get(selection.selectedItemIndex);
+        DesignCore.Scene.selectionManager.removeLastSelection();
         DesignCore.Scene.inputManager.actionCommand();
       }
-    } catch (error) {
+
+      DesignCore.Scene.inputManager.executeCommand();
+    } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
   }
 
-  action() {
-    const item = this.selectedIndex;
+  /**
+   * Preview the command during execution
+   */
+  preview() {
+    // No Preview
+  }
 
-    if (item !== undefined) {
+  /**
+   * Perform the command
+   */
+  action() {
+    if (this.selectedItem && this.selectedBoundaryItems.length) {
       const intersectPoints = [];
-      let TrimItem;
 
-      for (let i = 0; i <DesignCore.Scene.selectionManager.selectionSet.selectionSet.length; i++) {
-        if (DesignCore.Scene.selectionManager.selectionSet.selectionSet[i] !== item) {
-          const boundaryItem = DesignCore.Scene.items[DesignCore.Scene.selectionManager.selectionSet.selectionSet[i]];
-          TrimItem = DesignCore.Scene.items[item];
-
-          const functionName = 'intersect' + boundaryItem.type + TrimItem.type;
-          const intersect = Intersection[functionName](boundaryItem.intersectPoints(), TrimItem.intersectPoints());
-
-          if (intersect.points.length) {
-            for (let point = 0; point < intersect.points.length; point++) {
-              intersectPoints.push(intersect.points[point]);
+      for (const boundaryItem of this.selectedBoundaryItems) {
+        if (boundaryItem !== this.selectedItem) {
+          try {
+            const intersect = Intersection.intersectPolylinePolyline(boundaryItem.toPolylinePoints(), this.selectedItem.toPolylinePoints());
+            if (intersect.points.length) {
+              for (let point = 0; point < intersect.points.length; point++) {
+                intersectPoints.push(intersect.points[point]);
+              }
             }
+          } catch {
+            Logging.instance.warn(`${this.constructor.name}: Error intersecting between ${boundaryItem.type} and ${this.selectedItem.type}`);
+            continue;
           }
         }
       }
 
-      if (intersectPoints) {
-        TrimItem.trim(intersectPoints);
+      if (intersectPoints.length) {
+        const stateChanges = this.selectedItem.trim(intersectPoints);
+        if (stateChanges?.length) {
+          DesignCore.Scene.commit(stateChanges);
+        }
+      } else {
+        DesignCore.Core.notify(`${this.type} - ${this.selectedItem.type} ${Strings.Message.NOTRIM}`);
       }
-
-      // remove item from selection set and reset the selectedIndex
-      DesignCore.Scene.selectionManager.removeFromSelectionSet(this.selectedIndex);
-      this.selectedIndex = undefined;
     }
+
+    // reset selected item
+    this.selectedItem = null;
   }
 }