@design-core/core 0.0.1 → 0.0.3

package/core/entities/arc.js

@@ -1,28 +1,38 @@
-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 { 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 { AddState, RemoveState } from '../lib/stateManager.js';
+
+import { DesignCore } from '../designCore.js';
+import { Property } from '../properties/property.js';
+
+/**
+ * Arc Entity Class
+ * @extends Entity
+ * */
 export class Arc extends Entity {
+  /**
+   * Create an Arc Entity
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
     this.radius = 1;
 
-    // direction: - ccw > 0, cw < 0
+    // direction: - ccw > 0, cw <= 0
+    // default to 1 - counter clockwise
     Object.defineProperty(this, 'direction', {
       value: 1,
       writable: true,
     });
 
     if (data) {
-      if (data.points || data[40]) {
+      if (data.hasOwnProperty('points') || data.hasOwnProperty('40')) {
         // DXF Groupcode 40 - Radius
         // get the radius from the points or the incoming dxf groupcode
         const radius = this.points[1] ? this.points[0].distance(this.points[1]) : data[40];
@@ -32,52 +42,106 @@ export class Arc extends Entity {
         }
       }
 
-      if (data.hasOwnProperty('startAngle') || data[50]) {
+      if (data.hasOwnProperty('startAngle') || data.hasOwnProperty('50')) {
         // DXF Groupcode 50 - Start Angle
-        const angle = Utils.degrees2radians(data.startAngle || data[50]);
-        this.points[1] = this.points[0].project(angle, this.radius);
+
+        const angle = Property.loadValue([data.startAngle, data[50]], 0);
+        const projectionAngle = Utils.degrees2radians(angle);
+        this.points[1] = this.points[0].project(projectionAngle, this.radius);
       }
 
-      if (data.hasOwnProperty('endAngle') || data[51]) {
+      if (data.hasOwnProperty('endAngle') || data.hasOwnProperty('51')) {
         // DXF Groupcode 51 - End Angle
-        const angle = Utils.degrees2radians(data.endAngle || data[51]);
-        this.points[2] = this.points[0].project(angle, this.radius);
+        const angle = Property.loadValue([data.endAngle, data[51]], 0);
+        const projectionAngle = Utils.degrees2radians(angle);
+        this.points[2] = this.points[0].project(projectionAngle, this.radius);
       }
 
-      if (data.hasOwnProperty('direction')) {
+      if (data.hasOwnProperty('direction') || data.hasOwnProperty('73')) {
         // No DXF Groupcode - Arc Direction
-        const direction = data.direction;
-        this.direction = direction;
+        this.direction = Property.loadValue([data.direction, data[73]], 1);
       }
     }
   }
 
+  /**
+   * 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: 'Arc', shortcut: 'A', type: 'Entity'};
+    const command = { command: 'Arc', shortcut: 'A', 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.CENTER, [Input.Type.POINT]);
       const pt = await DesignCore.Scene.inputManager.requestInput(op);
+      if (pt === undefined) return;
       this.points.push(pt);
 
       const op1 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
       const pt1 = await DesignCore.Scene.inputManager.requestInput(op1);
+      if (pt1 === undefined) return;
       this.points.push(pt1);
 
-      const op2 = new PromptOptions(Strings.Input.ANGLE, [Input.Type.POINT, Input.Type.NUMBER]);
-      const 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(0);
-        const startPoint = this.points.at(1);
-        const angle = Utils.degrees2radians(pt2);
-        const point = startPoint.rotate(basePoint, angle);
-        this.points.push(point);
+      let pt2;
+      while (true) {
+        const op2 = new PromptOptions(`${Strings.Input.END} ${Strings.Strings.OR} ${Strings.Input.ANGLE}`, [Input.Type.POINT, Input.Type.NUMBER]);
+        pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
+        if (pt2 === undefined) return;
+
+        if (Input.getType(pt2) === Input.Type.POINT) {
+          // Must not be same as center or start
+          const center = this.points[0];
+          const start = this.points[1];
+          if (pt2.isSame?.(center) || pt2.isSame?.(start)) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
+            continue;
+          }
+          this.points.push(pt2);
+          // Infer arc direction using cross product if we have 3 points
+          if (this.points.length === 3) {
+            this.direction = Arc.#inferDirection(this.points[0], this.points[1], this.points[2]);
+            // Check total angle > 1 degree
+            if (Math.abs(this.totalAngle) <= 1) {
+              this.points.pop(); // Remove invalid end point
+              DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}: ${Strings.Error.MINVALUE}`);
+              continue;
+            }
+          }
+          break;
+        } else if (Input.getType(pt2) === Input.Type.NUMBER) {
+          // Must be a valid angle in (0, 360]
+          const angleValue = Number(pt2);
+          if (!Number.isFinite(angleValue) || Math.abs(angleValue) <= 0 || Math.abs(angleValue) > 360) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}`);
+            continue;
+          }
+          const basePoint = this.points.at(0);
+          const startPoint = this.points.at(1);
+          const angle = Utils.degrees2radians(angleValue);
+          const point = startPoint.rotate(basePoint, angle);
+          this.points.push(point);
+          // Set direction based on sign of angle
+          this.direction = angle >= 0 ? 1 : -1;
+          // Check total angle > 1 degree
+          if (Math.abs(this.totalAngle) <= 1) {
+            this.points.pop(); // Remove invalid end point
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDNUMBER}: ${Strings.Error.MINVALUE}`);
+            continue;
+          }
+          break;
+        } else {
+          DesignCore.Core.notify(`${this.type} - ${Strings.Error.INPUT}`);
+        }
       }
 
       DesignCore.Scene.inputManager.executeCommand(this);
@@ -86,71 +150,258 @@ export class Arc extends Entity {
     }
   }
 
+  /**
+   * Preview the entity during creation
+   */
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       const points = [this.points.at(0), mousePoint];
-      DesignCore.Scene.createTempItem('Line', {points: points});
+      DesignCore.Scene.tempEntities.create('Line', { points: points });
     }
 
     if (this.points.length >= 2) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       const points = [...this.points, mousePoint];
-      DesignCore.Scene.createTempItem(this.type, {points: points});
+
+      // Infer direction for preview, so it matches what will be created
+      let direction = 1;
+      if (points.length === 3) {
+        direction = Arc.#inferDirection(points[0], points[1], points[2]);
+      }
+
+      DesignCore.Scene.tempEntities.create(this.type, { points: points, direction: direction });
+    }
+  }
+
+  /**
+   * Infer arc direction from three points using cross product
+   * @param {Point} center
+   * @param {Point} start
+   * @param {Point} end
+   * @return {number} 1 for ccw, -1 for cw
+   */
+  static #inferDirection(center, start, end) {
+    // All points must be defined and distinct
+    if (!center || !start || !end) {
+      return 1; // Default to counterclockwise
+    }
+    if (center.isSame?.(start) || center.isSame?.(end) || start.isSame?.(end)) {
+      return 1;
     }
+
+    const v1 = start.subtract(center);
+    const v2 = end.subtract(center);
+    const cross = v1.cross(v2);
+    const direction = cross > 0 ? 1 : -1;
+    return direction;
   }
 
+  /**
+   * Arc start angle
+   * @return {number} start angle in radians
+   */
   startAngle() {
     return this.points[0].angle(this.points[1]);
   }
 
+  /**
+   * Arc end angle
+   * @return {number} end angle in radians
+   */
   endAngle() {
-    return this.points[0].angle(this.points[2]);
+    const endAngle = this.points[0].angle(this.points[2]);
+    return endAngle;
   }
 
+  /**
+   * Calculate the angle between the start and end of the arc
+   * Clockwise returns positive angle
+   * Counter clockwise returns negative
+   * @return {number} angle in degrees
+   */
+  get totalAngle() {
+    let startAngle = this.startAngle();
+    let endAngle = this.endAngle();
+
+
+    if (this.direction > 0) {
+      if (startAngle > endAngle || startAngle === endAngle) {
+        endAngle += (Math.PI * 2);
+      }
+    } else {
+      startAngle += (Math.PI * 2);
+    }
+
+    const totalAngle = (startAngle - endAngle);
+    return Utils.radians2degrees(totalAngle);
+  }
+
+  /**
+   * Get Arc radius
+   * @return {number} - arc radius
+   */
   getRadius() {
     return this.radius;
   }
 
+  /**
+   * Draw the entity
+   * @param {Object} ctx - context
+   * @param {number} scale
+   */
   draw(ctx, scale) {
-    ctx.arc(this.points[0].x, this.points[0].y, this.radius, this.startAngle(), this.endAngle());
+    ctx.arc(this.points[0].x, this.points[0].y, this.radius, this.direction > 0 ? this.startAngle() : this.endAngle(), this.direction > 0 ? this.endAngle() : this.startAngle());
     ctx.stroke();
   }
 
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
   dxf(file) {
     file.writeGroupCode('0', 'ARC');
-    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', 'AcDbCircle', DXFFile.Version.R2000);
     file.writeGroupCode('8', this.layer); // LAYERNAME
+    file.writeGroupCode('6', this.lineType); // LINETYPE
     file.writeGroupCode('10', this.points[0].x); // X
     file.writeGroupCode('20', this.points[0].y); // Y
     file.writeGroupCode('30', '0.0'); // Z
+    file.writeGroupCode('39', this.lineWidth); // Line Width
     file.writeGroupCode('40', this.radius); // Radius
     file.writeGroupCode('100', 'AcDbArc', DXFFile.Version.R2000);
-    file.writeGroupCode('50', Utils.radians2degrees(this.startAngle())); // Start Angle
-    file.writeGroupCode('51', Utils.radians2degrees(this.endAngle())); // End Angle
+    file.writeGroupCode('50', Utils.radians2degrees(this.direction > 0 ? this.startAngle() : this.endAngle())); // Start Angle
+    file.writeGroupCode('51', Utils.radians2degrees(this.direction > 0 ? this.endAngle() : this.startAngle())); // End Angle
   }
 
-  intersectPoints() {
-    return {
-      centre: this.points[0],
-      startPoint: this.points[1],
-      endPoint: this.points[2],
-      radius: this.radius,
-      direction: this.direction,
-    };
+  /**
+   * Return a list of points representing a polyline version of this entity
+   * @return {Array}
+   */
+  toPolylinePoints() {
+    // counter clockwise bulge = +ve, clockwise bulge = -ve,
+    // ccw arc = 0, clockwise arc = 1
+
+    // If the arc forms a complete circle
+    // Split into two separate polyline arcs
+    if (Math.abs(this.totalAngle) === 360) {
+      const startPoint = this.points[0].project(0, this.radius);
+      startPoint.bulge = 1;
+      const endPoint = this.points[0].project(0, -this.radius);
+      endPoint.bulge = 1;
+      const closurePoint = this.points[0].project(0, this.radius);
+      return [startPoint, endPoint, closurePoint];
+    }
+
+    const startPoint = this.points[0].project(this.startAngle(), this.radius);
+    const bulge = Math.tan(Utils.degrees2radians(-this.totalAngle % 360) / 4);
+    startPoint.bulge = bulge;
+    const endPoint = this.points[0].project(this.endAngle(), this.radius);
+    return [startPoint, endPoint];
+  }
+
+  /**
+   * Set entity points from a polyline point representation
+   * @param {Array} points
+   */
+  fromPolylinePoints(points) {
+    const center = points[0].bulgeCentrePoint(points[1]);
+    const radius = center.distance(points[0]);
+    this.points = [center, new Point(points[0].x, points[0].y), new Point(points[1].x, points[1].y)];
+    this.radius = radius;
   }
 
+  /**
+   * 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;
+    }
+
+    // get the mouse position
+    const mousePosition = DesignCore.Mouse.pointOnScene();
+    // get the point on the arc closest to the mouse
+    const pointOnArc = mousePosition.closestPointOnArc(this.points[1], this.points[2], this.points[0], this.direction);
+    // remove any intersections that are at the end points of the arc
+    intersections = intersections.filter((p) => !p.isSame(this.points[1]) && !p.isSame(this.points[2]));
+    // sort intersection points by distance to start point
+    Utils.sortPointsOnArc(intersections, this.points[1], this.points[2], this.points[0], this.direction);
+    // Add arc points to the start and the end of the point array
+    const testPoints = [this.points[1], ...intersections, this.points[2]];
+
+    // 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 (pointOnArc.isOnArc(startPoint, endPoint, this.points[0], this.direction)) {
+          // Store new entity points
+          const newPoints = [];
+
+          for (const p of testPoints) {
+            const inOriginalArc = 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 arc
+            const isBetween = p.isSame(startPoint) || p.isSame(endPoint);
+            if ((isBetween && inIntersections) || (!isBetween && inOriginalArc)) {
+              newPoints.push(p);
+            }
+          }
+
+          if (newPoints.length % 2 === 0) {
+            // Add arcs for each point pair
+            for (let j = 0; j < newPoints.length; j += 2) {
+              const arc = Utils.cloneObject(this);
+              arc.points = [this.points[0], newPoints[j], newPoints[j + 1]];
+              const addState = new AddState(arc);
+              stateChanges.push(addState);
+            }
+          }
+
+          if (stateChanges.length > 0) {
+            // Remove the existing arc
+            const removeState = new RemoveState(this);
+            stateChanges.push(removeState);
+          }
+        }
+      }
+    }
+
+    return stateChanges;
+  }
+
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
   snaps(mousePoint, delta) {
     const snaps = [];
 
     if (DesignCore.Settings.endsnap) {
       // Speed this up by generating the proper start and end points when the arc is initialised
-      const startPoint = new Point(this.points[0].x + (this.radius * Math.cos(this.startAngle())),
-          this.points[0].y + (this.radius * Math.sin(this.startAngle())));
-      const endPoint = new Point(this.points[0].x + (this.radius * Math.cos(this.endAngle())),
-          this.points[0].y + (this.radius * Math.sin(this.endAngle())));
+      const startPoint = new Point(
+          this.points[0].x + (this.radius * Math.cos(this.startAngle())),
+          this.points[0].y + (this.radius * Math.sin(this.startAngle())),
+      );
+      const endPoint = new Point(
+          this.points[0].x + (this.radius * Math.cos(this.endAngle())),
+          this.points[0].y + (this.radius * Math.sin(this.endAngle())),
+      );
 
       snaps.push(startPoint, endPoint);
     }
@@ -169,17 +420,20 @@ export class Arc extends Entity {
       }
     }
 
-
     return snaps;
   }
 
+  /**
+   * Get closest point on entity
+   * @param {Point} P
+   * @return {Array} - [Point, distance]
+   */
   closestPoint(P) {
     const startPoint = this.points[1];
     const endPoint = this.points[2];
     const centerPoint = this.points[0];
-    // TODO: enable defining clockwise arcs
-    const direction = 1;
-    const pnt = P.closestPointOnArc(startPoint, endPoint, centerPoint, direction);
+
+    const pnt = P.closestPointOnArc(startPoint, endPoint, centerPoint, this.direction);
 
     if (pnt !== null) {
       const distance = P.distance(pnt);
@@ -191,8 +445,8 @@ export class Arc extends Entity {
   }
 
   /**
-   * Return boundingbox
-   * @returns BoundingBox
+   * Return boundingbox for entity
+   * @return {BoundingBox}
    */
   boundingBox() {
     return BoundingBox.arcBoundingBox(this.points[0], this.points[1], this.points[2], this.direction);