@design-core/core 0.0.1 → 0.0.3

package/core/entities/line.js

@@ -1,20 +1,30 @@
-import {Point} from './point.js';
-import {Utils} from '../lib/utils.js';
-import {Strings} from '../lib/strings.js';
-import {Entity} from './entity.js';
-import {Input, PromptOptions} from '../lib/inputManager.js';
-import {Logging} from '../lib/logging.js';
-import {DXFFile} from '../lib/dxf/dxfFile.js';
-import {BoundingBox} from '../lib/boundingBox.js';
-
-import {DesignCore} from '../designCore.js';
-
+import { Point } from './point.js';
+import { Strings } from '../lib/strings.js';
+import { Entity } from './entity.js';
+import { Input, PromptOptions } from '../lib/inputManager.js';
+import { Logging } from '../lib/logging.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { BoundingBox } from '../lib/boundingBox.js';
+import { AddState, RemoveState, UpdateState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+import { Utils } from '../lib/utils.js';
+
+
+/**
+ * Line Entity Class
+ * @extends Entity
+ */
 export class Line extends Entity {
+  /**
+   * Create a Line Entity
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
 
     if (data) {
-      if (data.points) {
+      if (data.hasOwnProperty('points')) {
         // clear points
         this.points = [];
 
@@ -26,31 +36,43 @@ export class Line extends Entity {
     }
   }
 
-
+  /**
+   * 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: 'Line', shortcut: 'L', type: 'Entity'};
+    const command = { command: 'Line', shortcut: 'L', type: 'Entity' };
     return command;
   }
 
+  /**
+   * Execute method
+   * executes the workflow, requesting input required to create an entity
+   */
   async execute() {
     try {
       const op = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
       const pt1 = await DesignCore.Scene.inputManager.requestInput(op);
+      if (pt1 === undefined) return;
       this.points.push(pt1);
 
-      let pt2;
-      const op2 = new PromptOptions(Strings.Input.NEXTPOINT, [Input.Type.POINT, Input.Type.NUMBER]);
       while (true) {
-        pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
-        if (Input.getType(pt2) === Input.Type.POINT) {
-          this.points.push(pt2);
-        } else if (Input.getType(pt2) === Input.Type.NUMBER) {
-          const basePoint = this.points.at(-1);
-          const angle = Utils.degrees2radians(DesignCore.Mouse.inputAngle());
-          const point = basePoint.project(angle, pt2);
-          this.points.push(point);
+        const canClose = this.points.length >= 3;
+        const options = canClose ? ['Close'] : [];
+        const op2 = new PromptOptions(Strings.Input.NEXTPOINT, [Input.Type.POINT, Input.Type.DYNAMIC], options);
+        const pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
+        if (pt2 === undefined) break;
+
+        if (Input.getType(pt2) === Input.Type.STRING && pt2 === 'Close') {
+          this.points.push(pt1);
+          DesignCore.Scene.inputManager.executeCommand(this);
+          return;
         }
 
+        this.points.push(pt2);
         DesignCore.Scene.inputManager.actionCommand(this);
       }
     } catch (err) {
@@ -58,172 +80,193 @@ export class Line extends Entity {
     }
   }
 
+  /**
+   * Preview the entity during creation
+   */
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       const points = [this.points.at(-1), mousePoint];
-      DesignCore.Scene.createTempItem(this.type, {points: points});
+      DesignCore.Scene.tempEntities.create(this.type, { points: points });
     }
   }
 
+  /**
+   * Draw the entity
+   * @param {Object} ctx - context
+   * @param {number} scale
+   */
   draw(ctx, scale) {
     ctx.moveTo(this.points[0].x, this.points[0].y);
     ctx.lineTo(this.points[1].x, this.points[1].y);
     ctx.stroke();
   }
 
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
   dxf(file) {
     file.writeGroupCode('0', 'LINE');
-    file.writeGroupCode('5', file.nextHandle(), DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
     file.writeGroupCode('100', 'AcDbEntity', DXFFile.Version.R2000);
     file.writeGroupCode('100', 'AcDbLine', DXFFile.Version.R2000);
     file.writeGroupCode('8', this.layer);
+    file.writeGroupCode('6', this.lineType);
     file.writeGroupCode('10', this.points[0].x);
     file.writeGroupCode('20', this.points[0].y);
     file.writeGroupCode('30', '0.0');
     file.writeGroupCode('11', this.points[1].x);
     file.writeGroupCode('21', this.points[1].y);
     file.writeGroupCode('31', '0.0');
+    file.writeGroupCode('39', this.lineWidth);
   }
 
-  trim(points) {
-    function trimOneEnd(intersectPnts, line) {
-      let originPoint;
-      let destinationPoint;
-      const validPoints = [];
-
-      for (let i = 0; i < line.points.length; i++) {
-        for (let j = 0; j < intersectPnts.length; j++) {
-          if (betweenPoints(DesignCore.Mouse.pointOnScene(), [intersectPnts[j], line.points[i]], false)) {
-            if (Math.round(intersectPnts[j].distance(line.points[i]) * 100) / 100 < Math.round(line.points[0].distance(line.points[1]) * 100) / 100) {
-              originPoint = i;
-              validPoints.push(j);
-            }
-          }
-        }
-      }
-
-      if (typeof validPoints !== 'undefined') {
-        let dist = Number.POSITIVE_INFINITY;
-
-        for (let j = 0; j < validPoints.length; j++) {
-          if (line.points[originPoint].distance(intersectPnts[validPoints[j]]) < dist) {
-            dist = line.points[originPoint].distance(intersectPnts[validPoints[j]]);
-            destinationPoint = validPoints[j];
-          }
-        }
-      }
+  /**
+   * Return a list of points representing a polyline version of this entity
+   * @return {Array}
+   */
+  toPolylinePoints() {
+    return this.points;
+  }
 
-      if (typeof destinationPoint !== 'undefined') {
-        line.points[originPoint] = intersectPnts[destinationPoint];
-      }
-    }
+  /**
+   * Set entity points from a polyline point representation
+   * @param {Array} points
+   */
+  fromPolylinePoints(points) {
+    this.points = [new Point(points[0].x, points[0].y), new Point(points[1].x, points[1].y)];
+  }
 
-    function trimBetween(pnts, line) {
-      const a = Math.round(line.points[0].distance(pnts[0]));
-      const b = Math.round(line.points[0].distance(pnts[1]));
-      const c = Math.round(line.points[1].distance(pnts[0]));
-      const d = Math.round(line.points[1].distance(pnts[1]));
-
-      if (a === 0 && d === 0 || b === 0 && c === 0) {
-      } else {
-        const data = {
-          points: [pnts[a < b ? 1 : 0], line.points[1]],
-          colour: line.colour,
-          layer: line.layer,
-          lineWidth: line.lineWidth,
-        };
-
-        DesignCore.Scene.addItem('Line', data);
-
-        if (a < b) {
-          line.points[1] = pnts[0];
-        } else {
-          line.points[1] = pnts[1];
-        }
-      }
+  /**
+   * Trim the entity
+   * @param {Array} intersections
+   * @return {Array} - array of state changes
+   */
+  trim(intersections) {
+    // array to hold state changes
+    const stateChanges = [];
+
+    if (intersections?.length === 0 || !intersections) {
+      return stateChanges;
     }
 
-    function betweenPoints(mousePnt, pntsArray, returnPoints) {
-      for (let i = 0; i < pntsArray.length - 1; i++) {
-        const a = pntsArray[i].distance(mousePnt);
-        const b = pntsArray[i + 1].distance(mousePnt);
-        const c = pntsArray[i].distance(pntsArray[i + 1]);
-
-        if (Math.round(a + b) === Math.round(c)) {
-          if (returnPoints) {
-            return [pntsArray[i], pntsArray[i + 1]];
+    // get the mouse position
+    const mousePosition = DesignCore.Mouse.pointOnScene();
+    // get the point on the line closest to the mouse
+    const pointOnLine = mousePosition.closestPointOnLine(this.points[0], this.points[1]);
+    // remove any intersections that are at the end points of the line
+    intersections = intersections.filter((p) => !p.isSame(this.points[0]) && !p.isSame(this.points[1]));
+
+    Utils.sortPointsByDistance(intersections, this.points[0]);
+
+    // Add line points to the start and the end of the point array
+    const testPoints = [this.points[0], ...intersections, this.points[1]];
+
+    // Test if mouse position is between two intersection points
+    if (testPoints.length > 1) {
+      for (let i = 0; i < testPoints.length - 1; i++) {
+        const startPoint = testPoints[i];
+        const endPoint = testPoints[i + 1];
+
+        // check if the mouse is between startPoint and endPoint
+        if (pointOnLine.isOnLine(startPoint, endPoint)) {
+          const newPoints = [];
+
+          for (const p of testPoints) {
+            const inOriginalLine = this.points.indexOf(p) !== -1;
+            const inIntersections = intersections.indexOf(p) !== -1;
+
+            // Keep points which:
+            // - The mouse is between are intersections
+            // - The mouse is not between and in this line
+            const isBetween = p.isSame(startPoint) || p.isSame(endPoint);
+            if ((isBetween && inIntersections) || (!isBetween && inOriginalLine)) {
+              newPoints.push(p);
+            }
           }
 
-          return true;
+          if (newPoints.length % 2 === 0) {
+            // Add lines for each point pair
+            for (let j = 0; j < newPoints.length; j += 2) {
+              const line = Utils.cloneObject(this);
+              line.points = [newPoints[j], newPoints[j + 1]];
+              const addState = new AddState(line);
+              stateChanges.push(addState);
+            }
+          }
+          // Remove the existing line
+          const removeState = new RemoveState(this);
+          stateChanges.push(removeState);
         }
       }
     }
 
-    if (points.length > 1) {
-      // is the mouse between two points
-      const pnts = betweenPoints(DesignCore.Mouse.pointOnScene(), points, true);
+    return stateChanges;
+  }
 
-      if (typeof pnts !== 'undefined') {
-        trimBetween(pnts, this);
-      } else {
-        trimOneEnd(points, this);
-      }
-    } else {
-      trimOneEnd(points, this);
+  /**
+   * Extend the entity
+   * @param {Array} intersections
+   * @return {Array} - array of state changes
+   */
+  extend(intersections) {
+    // array to hold state changes
+    const stateChanges = [];
+
+    if (intersections?.length === 0 || !intersections) {
+      return stateChanges;
     }
-  }
 
-  extend(points) {
     let originPoint;
-    let destinationPoint;
-
     // Find which end is closer to the mouse
-    // ToDo: Pass the mouse location in rather than needing a ref to core.
     if (this.points[0].distance(DesignCore.Mouse.pointOnScene()) < this.points[1].distance(DesignCore.Mouse.pointOnScene())) {
       originPoint = 0;
     } else {
       originPoint = 1;
     }
 
-    // check if any of the points are valid
-    const validPoints = [];
+    Utils.sortPointsByDistance(intersections, this.points[originPoint]);
 
-    for (let i = 0; i < points.length; i++) {
-      if (Math.round(this.points[originPoint].angle(points[i])) === Math.round(this.points[originPoint ? 0 : 1].angle(this.points[originPoint]))) {
-        // if the destination point is different than the origin add it to the array of valid points
-        if (Math.round(this.points[originPoint].distance(points[i])) !== 0) {
-          validPoints.push(i);
-        }
-      }
-    }
+    const endPoint = this.points[originPoint];
+    const adjacentPoint = this.points[1 - originPoint];
 
-    if (validPoints.length > 1) {
-      let dist = Number.POSITIVE_INFINITY;
+    // Find the closest intersection that lies beyond the endpoint
+    const direction = endPoint.subtract(adjacentPoint);
+    const newEndPoint = intersections.find((p) => {
+      if (p.isSame(endPoint)) return false;
+      if (p.subtract(endPoint).dot(direction) <= 0) return false;
+      if (adjacentPoint.distance(p) <= adjacentPoint.distance(endPoint)) return false;
+      return true;
+    });
 
-      for (let j = 0; j < validPoints.length; j++) {
-        if (this.points[originPoint].distance(points[validPoints[j]]) < dist) {
-          dist = this.points[originPoint].distance(points[validPoints[j]]);
-          destinationPoint = validPoints[j];
-        }
-      }
-    } else if (validPoints.length === 1) {
-      // only one valid point
-      destinationPoint = validPoints[0];
+    if (!newEndPoint) {
+      return stateChanges;
     }
 
-    if (destinationPoint !== undefined) {
-      this.points[originPoint] = points[destinationPoint];
+    const newPoints = [];
+    if (originPoint === 0) {
+      newPoints.push(newEndPoint, this.points[1]);
+    } else {
+      newPoints.push(this.points[0], newEndPoint);
     }
-  }
 
-  intersectPoints() {
-    return {
-      start: this.points[0],
-      end: this.points[1],
-    };
+    if (newPoints[0].isSame(this.points[0]) && newPoints[1].isSame(this.points[1])) {
+      // No change
+      return stateChanges;
+    }
+
+    // update the line
+    const addState = new UpdateState(this, { points: newPoints });
+    stateChanges.push(addState);
+
+    return stateChanges;
   }
 
+  /**
+   * Get the length of a line
+   * @return {number}
+   */
   length() {
     const A = (this.points[0].x - this.points[1].x);
     const B = (this.points[0].y - this.points[1].y);
@@ -234,11 +277,21 @@ export class Line extends Entity {
     return dist;
   }
 
+  /**
+   * Get the lines mid point
+   * @return {Point}
+   */
   midPoint() {
     const midPoint = this.points[0].midPoint(this.points[1]);
     return midPoint;
   }
 
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
   snaps(mousePoint, delta) {
     const snaps = [];
 
@@ -264,6 +317,11 @@ export class Line extends Entity {
     return snaps;
   }
 
+  /**
+   * Get closest point on entity
+   * @param {Point} P
+   * @return {Array} - [Point, distance]
+   */
   closestPoint(P) {
     const pnt = P.closestPointOnLine(this.points[0], this.points[1]);
     if (pnt === null) {
@@ -274,6 +332,10 @@ export class Line extends Entity {
     return [pnt, distance];
   }
 
+  /**
+   * Return boundingbox for entity
+   * @return {BoundingBox}
+   */
   boundingBox() {
     return BoundingBox.lineBoundingBox(this.points[0], this.points[1]);
   }

package/core/entities/lwpolyline.js

@@ -1,62 +1,39 @@
-import {Logging} from '../lib/logging.js';
-import {BasePolyline} from './basePolyline.js';
+import { Logging } from '../lib/logging.js';
+import { BasePolyline } from './basePolyline.js';
+import { Polyline } from './polyline.js';
 
+/**
+ * LWPolyline Entity Class
+ * @extends BasePolyline
+ */
 export class Lwpolyline extends BasePolyline {
+  /**
+   * Create an LW Polyline
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
 
     if (data) {
-      if (data[90]) {
+      if (data.hasOwnProperty('90')) {
         // DXF Groupcode 90 - Number of vertices
         if (this.points.length !== data[90]) {
           Logging.instance.error(`LWPOLYLINE Vertices Count`);
         }
       }
     }
+    return new Polyline(data);
   }
 
+  /**
+   * 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: 'Lwpolyline'};
+    const command = { command: 'Lwpolyline' };
     return command;
   }
-
-  // dxf
-  // R12 doesn't support Lwpolyline
-  // output as polyline definition by default from super class
-  /*
-  dxf() {
-    let pointData = '';
-    this.points.forEach((point) => {
-      pointData = pointData.concat(
-          '\n', '10', // X
-          '\n', point.x,
-          '\n', '20', // Y
-          '\n', point.y,
-          '\n', '30', // Z
-          '\n', '0',
-          '\n', '42', // bulge
-          '\n', point.bulge,
-      );
-    });
-
-    const dxfitem = '';
-    const data = dxfitem.concat(
-        '0',
-        '\n', 'LWPOLYLINE',
-        // "\n", "5", //HANDLE
-        // "\n", "DA",
-        '\n', '8', // LAYERNAME
-        '\n', this.layer,
-        '\n', '39', // Line Width
-        '\n', this.lineWidth,
-        '\n', '70', // Flags
-        '\n', this.flags,
-        '\n', '90', // Vertex count
-        '\n', this.points.length,
-        pointData,
-
-    );
-    return data;
-  }
-  */
 }