@design-core/core 0.0.6 → 50.1.0

package/core/entities/arc.js

@@ -6,11 +6,12 @@ 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';
-import { SnapPoint } from '../lib/snapping.js';
+import { SnapPoint } from '../lib/auxiliary/snapPoint.js';
+import { RubberBand } from '../lib/auxiliary/rubberBand.js';
 
 /**
  * Arc Entity Class
@@ -25,46 +26,32 @@ export class Arc extends Entity {
    */
   constructor(data) {
     super(data);
-    this.radius = 1;
-
-    // direction: - ccw > 0, cw <= 0
-    // default to 1 - counter clockwise
-    Object.defineProperty(this, 'direction', {
-      value: 1,
-      writable: true,
-    });
 
-    if (data) {
-      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];
-
-        if (radius !== undefined) {
-          this.radius = radius;
-        }
+    // If only the centre point is present, project start/end from named scalar properties.
+    // Full-points data (post-execute or post-fromDxf) skips this block entirely.
+    if (data && this.points.length < 2) {
+      const radius = data.radius ?? 1;
+      if (data.hasOwnProperty('startAngle')) {
+        this.points[1] = this.points[0].project(Utils.degrees2radians(data.startAngle), radius);
       }
-
-      if (data.hasOwnProperty('startAngle') || data.hasOwnProperty('50')) {
-        // DXF Groupcode 50 - Start Angle
-
-        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')) {
+        this.points[2] = this.points[0].project(Utils.degrees2radians(data.endAngle), radius);
       }
+    }
 
-      if (data.hasOwnProperty('endAngle') || data.hasOwnProperty('51')) {
-        // DXF Groupcode 51 - End Angle
-        const angle = Property.loadValue([data.endAngle, data[51]], 0);
-        const projectionAngle = Utils.degrees2radians(angle);
-        this.points[2] = this.points[0].project(projectionAngle, this.radius);
-      }
+    // direction: ccw > 0, cw <= 0
+    this.properties.add(Property.Names.DIRECTION, {
+      type: Property.Type.NUMBER,
+      value: data?.direction ?? 1,
+      dxfCode: 73,
+    });
 
-      if (data.hasOwnProperty('direction') || data.hasOwnProperty('73')) {
-        // No DXF Groupcode - Arc Direction
-        this.direction = Property.loadValue([data.direction, data[73]], 1);
-      }
-    }
+    // radius: computed from points — stored in EntityProperties
+    this.properties.add(Property.Names.RADIUS, {
+      type: Property.Type.NUMBER,
+      get: (entity) => entity.points[1] ? entity.points[0].distance(entity.points[1]) : 1,
+      dxfCode: 40,
+    });
   }
 
   /**
@@ -79,6 +66,30 @@ export class Arc extends Entity {
     return command;
   }
 
+  /**
+   * Normalise DXF group codes into the canonical points-based representation.
+   * Called by the DXF loader before construction.
+   * @param {Object} data
+   * @return {Object}
+   */
+  static fromDxf(data) {
+    const centre = data.points?.[0];
+    if (!centre) return data;
+    // validate required group codes for points-based arc representation are present
+    if (data[40] === undefined || data[50] === undefined || data[51] === undefined) return data;
+
+    const radius = data[40];
+    return {
+      ...data,
+      points: [
+        centre,
+        centre.project(Utils.degrees2radians(data[50] ?? 0), radius),
+        centre.project(Utils.degrees2radians(data[51] ?? 0), radius),
+      ],
+      direction: data[73] ?? 1,
+    };
+  }
+
   /**
    * Execute method
    * executes the workflow, requesting input required to create an entity
@@ -90,29 +101,46 @@ export class Arc extends Entity {
       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;
+      let pt1;
+      while (true) {
+        const op1 = new PromptOptions(Strings.Input.START, [Input.Type.POINT]);
+        pt1 = await DesignCore.Scene.inputManager.requestInput(op1);
+        if (pt1 === undefined) return;
+        if (pt1.isSame?.(pt)) {
+          DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
+          continue;
+        }
+        break;
+      }
       this.points.push(pt1);
 
       let pt2;
       while (true) {
+        DesignCore.Scene.inputManager.inputPoint = pt; // polar/ortho tracks from centre on each attempt
         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];
+          // Must not be same as centre or start
+          const centre = this.points[0];
           const start = this.points[1];
-          if (pt2.isSame?.(center) || pt2.isSame?.(start)) {
+          if (pt2.isSame?.(centre) || pt2.isSame?.(start)) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
+            continue;
+          }
+
+          const angle = this.points[0].angle(pt2);
+          const projectedEnd = this.points[0].project(angle, this.getProperty(Property.Names.RADIUS));
+          if (projectedEnd.isSame(this.points[1])) {
             DesignCore.Core.notify(`${this.type} - ${Strings.Error.INVALIDPOINT}`);
             continue;
           }
-          this.points.push(pt2);
+          this.points.push(projectedEnd);
+
           // 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]);
+            this.setProperty(Property.Names.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
@@ -134,7 +162,7 @@ export class Arc extends Entity {
           const point = startPoint.rotate(basePoint, angle);
           this.points.push(point);
           // Set direction based on sign of angle
-          this.direction = angle >= 0 ? 1 : -1;
+          this.setProperty(Property.Names.DIRECTION, angle >= 0 ? 1 : -1);
           // Check total angle > 1 degree
           if (Math.abs(this.totalAngle) <= 1) {
             this.points.pop(); // Remove invalid end point
@@ -159,13 +187,16 @@ export class Arc extends Entity {
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const points = [this.points.at(0), mousePoint];
-      DesignCore.Scene.tempEntities.create('Line', { points: points });
+      DesignCore.Scene.auxiliaryEntities.add(new RubberBand([this.points.at(0), mousePoint]));
     }
 
     if (this.points.length >= 2) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
-      const points = [...this.points, mousePoint];
+      // const points = [...this.points, mousePoint];
+      const centre = this.points[0];
+      const endPoint = centre.project(centre.angle(mousePoint), this.getProperty(Property.Names.RADIUS));
+      if (endPoint.isSame(this.points[1])) return;
+      const points = [...this.points, endPoint];
 
       // Infer direction for preview, so it matches what will be created
       let direction = 1;
@@ -173,28 +204,28 @@ export class Arc extends Entity {
         direction = Arc.#inferDirection(points[0], points[1], points[2]);
       }
 
-      DesignCore.Scene.tempEntities.create(this.type, { points: points, direction: direction });
+      DesignCore.Scene.previewEntities.create(this.type, { points: points, direction: direction });
     }
   }
 
   /**
    * Infer arc direction from three points using cross product
-   * @param {Point} center
+   * @param {Point} centre
    * @param {Point} start
    * @param {Point} end
    * @return {number} 1 for ccw, -1 for cw
    */
-  static #inferDirection(center, start, end) {
+  static #inferDirection(centre, start, end) {
     // All points must be defined and distinct
-    if (!center || !start || !end) {
+    if (!centre || !start || !end) {
       return 1; // Default to counterclockwise
     }
-    if (center.isSame?.(start) || center.isSame?.(end) || start.isSame?.(end)) {
+    if (centre.isSame?.(start) || centre.isSame?.(end) || start.isSame?.(end)) {
       return 1;
     }
 
-    const v1 = start.subtract(center);
-    const v2 = end.subtract(center);
+    const v1 = start.subtract(centre);
+    const v2 = end.subtract(centre);
     const cross = v1.cross(v2);
     const direction = cross > 0 ? 1 : -1;
     return direction;
@@ -228,7 +259,7 @@ export class Arc extends Entity {
     let endAngle = this.endAngle();
 
 
-    if (this.direction > 0) {
+    if (this.getProperty(Property.Names.DIRECTION) > 0) {
       if (startAngle > endAngle || startAngle === endAngle) {
         endAngle += (Math.PI * 2);
       }
@@ -245,7 +276,7 @@ export class Arc extends Entity {
    * @return {number} - arc radius
    */
   getRadius() {
-    return this.radius;
+    return this.getProperty(Property.Names.RADIUS);
   }
 
   /**
@@ -253,9 +284,12 @@ export class Arc extends Entity {
    * @param {Object} ctx - context
    * @param {number} scale
    */
-  draw(ctx, scale) {
-    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();
+  /**
+   * Draw the arc
+   * @param {Object} renderer
+   */
+  draw(renderer) {
+    renderer.drawShape(this.toPolylinePoints());
   }
 
   /**
@@ -264,19 +298,19 @@ export class Arc extends Entity {
    */
   dxf(file) {
     file.writeGroupCode('0', 'ARC');
-    file.writeGroupCode('5', this.handle, DXFFile.Version.R2000); // Handle
+    file.writeGroupCode('5', this.getProperty(Property.Names.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('8', this.getProperty(Property.Names.LAYER)); // LAYERNAME
+    file.writeGroupCode('6', this.getProperty(Property.Names.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('39', this.getProperty(Property.Names.LINEWIDTH)); // Line Width
+    file.writeGroupCode('40', this.getProperty(Property.Names.RADIUS)); // Radius
     file.writeGroupCode('100', 'AcDbArc', DXFFile.Version.R2000);
-    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
+    file.writeGroupCode('50', Utils.radians2degrees(this.getProperty(Property.Names.DIRECTION) > 0 ? this.startAngle() : this.endAngle())); // Start Angle
+    file.writeGroupCode('51', Utils.radians2degrees(this.getProperty(Property.Names.DIRECTION) > 0 ? this.endAngle() : this.startAngle())); // End Angle
   }
 
   /**
@@ -289,101 +323,32 @@ export class Arc extends Entity {
 
     // If the arc forms a complete circle
     // Split into two separate polyline arcs
+    const radius = this.getProperty(Property.Names.RADIUS);
     if (Math.abs(this.totalAngle) === 360) {
-      const startPoint = this.points[0].project(0, this.radius);
+      const startPoint = this.points[0].project(0, radius);
       startPoint.bulge = 1;
-      const endPoint = this.points[0].project(0, -this.radius);
+      const endPoint = this.points[0].project(0, -radius);
       endPoint.bulge = 1;
-      const closurePoint = this.points[0].project(0, this.radius);
+      const closurePoint = this.points[0].project(0, radius);
       return [startPoint, endPoint, closurePoint];
     }
 
-    const startPoint = this.points[0].project(this.startAngle(), this.radius);
+    const startPoint = this.points[0].project(this.startAngle(), radius);
     const bulge = Math.tan(Utils.degrees2radians(-this.totalAngle % 360) / 4);
     startPoint.bulge = bulge;
-    const endPoint = this.points[0].project(this.endAngle(), this.radius);
+    const endPoint = this.points[0].project(this.endAngle(), radius);
     return [startPoint, endPoint];
   }
 
   /**
    * Set entity points from a polyline point representation
    * @param {Array} points
+   * @return {Arc}
    */
   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;
+    const centre = points[0].bulgeCentrePoint(points[1]);
+    this.points = [centre, new Point(points[0].x, points[0].y), new Point(points.at(-1).x, points.at(-1).y)];
+    return this;
   }
 
   /**
@@ -417,12 +382,14 @@ export class Arc extends Entity {
       const angleFromCentreToInput = centre.angle(fromPoint); // angle from centre toward fromPoint
 
       // Tangent: only possible when fromPoint is outside the arc radius
-      if (distanceToCenter > this.radius) {
-        const tangentHalfAngle = Math.acos(this.radius / distanceToCenter); // half-angle between the two tangent directions
+      const radius = this.getProperty(Property.Names.RADIUS);
+      const direction = this.getProperty(Property.Names.DIRECTION);
+      if (distanceToCenter > radius) {
+        const tangentHalfAngle = Math.acos(radius / distanceToCenter); // half-angle between the two tangent directions
 
         for (const sign of [1, -1]) {
-          const tangentPoint = centre.project(angleFromCentreToInput + sign * tangentHalfAngle, this.radius);
-          if (tangentPoint.isOnArc(this.points[1], this.points[2], centre, this.direction)) {
+          const tangentPoint = centre.project(angleFromCentreToInput + sign * tangentHalfAngle, radius);
+          if (tangentPoint.isOnArc(this.points[1], this.points[2], centre, direction)) {
             snaps.push(new SnapPoint(tangentPoint, SnapPoint.Type.TANGENT));
           }
         }
@@ -430,8 +397,8 @@ export class Arc extends Entity {
 
       // Perpendicular: point on the arc that lies on the line from fromPoint through the centre
       if (distanceToCenter > 0) {
-        const perpendicularPoint = centre.project(angleFromCentreToInput, this.radius);
-        if (perpendicularPoint.isOnArc(this.points[1], this.points[2], centre, this.direction)) {
+        const perpendicularPoint = centre.project(angleFromCentreToInput, radius);
+        if (perpendicularPoint.isOnArc(this.points[1], this.points[2], centre, direction)) {
           snaps.push(new SnapPoint(perpendicularPoint, SnapPoint.Type.PERPENDICULAR));
         }
       }
@@ -448,9 +415,9 @@ export class Arc extends Entity {
   closestPoint(P) {
     const startPoint = this.points[1];
     const endPoint = this.points[2];
-    const centerPoint = this.points[0];
+    const centrePoint = this.points[0];
 
-    const pnt = P.closestPointOnArc(startPoint, endPoint, centerPoint, this.direction);
+    const pnt = P.closestPointOnArc(startPoint, endPoint, centrePoint, this.getProperty(Property.Names.DIRECTION));
 
     if (pnt !== null) {
       const distance = P.distance(pnt);
@@ -466,6 +433,6 @@ export class Arc extends Entity {
    * @return {BoundingBox}
    */
   boundingBox() {
-    return BoundingBox.arcBoundingBox(this.points[0], this.points[1], this.points[2], this.direction);
+    return BoundingBox.arcBoundingBox(this.points[0], this.points[1], this.points[2], this.getProperty(Property.Names.DIRECTION));
   }
 }