@design-core/core 0.0.1 → 0.0.3

package/core/entities/circle.js

@@ -1,14 +1,25 @@
-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 {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 { Property } from '../properties/property.js';
+import { Utils } from '../lib/utils.js';
+
+import { DesignCore } from '../designCore.js';
+import { AddState, RemoveState } from '../lib/stateManager.js';
+
+/**
+ * Circle Entity Class
+ * @extends Entity
+ */
 export class Circle extends Entity {
+  /**
+   * Create a Circle Entity
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
 
@@ -20,111 +31,218 @@ export class Circle extends Entity {
       enumerable: true,
     });
 
-    // ensure a radius is set
-    // this.setRadius(1);
-
     if (data) {
-      if (data.radius || data[40]) {
+      if (data.hasOwnProperty('radius') || data.hasOwnProperty('40')) {
         // DXF Groupcode 40 - Radius
-        const radius = data.radius || data[40];
-        this.setRadius(radius);
+        this.setRadius(Property.loadValue([data.radius, data[40]], 0));
       }
     }
   }
 
+  /**
+   * 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: 'Circle', shortcut: 'C', type: 'Entity'};
+    const command = { command: 'Circle', shortcut: 'C', 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 op = new PromptOptions(Strings.Input.CENTER, [Input.Type.POINT]);
       const pt1 = await DesignCore.Scene.inputManager.requestInput(op);
+      if (pt1 === undefined) return;
       this.points.push(pt1);
 
-      const op2 = new PromptOptions(Strings.Input.RADIUS, [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);
+      const op2 = new PromptOptions(Strings.Input.RADIUS, [Input.Type.POINT, Input.Type.NUMBER], ['Diameter']);
+
+      while (true) {
+        const pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
+        if (pt2 === undefined) return;
+
+        if (Input.getType(pt2) === Input.Type.POINT) {
+          if (pt1.distance(pt2) <= 0) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.NONZERO}`);
+            continue;
+          }
+          this.points.push(pt2);
+          break;
+        } else if (Input.getType(pt2) === Input.Type.NUMBER) {
+          if (pt2 <= 0) {
+            DesignCore.Core.notify(`${this.type} - ${Strings.Error.NONZERO}`);
+            continue;
+          }
+          this.setRadius(pt2);
+          break;
+        } else if (Input.getType(pt2) === Input.Type.STRING && pt2 === 'Diameter') {
+          const op3 = new PromptOptions(Strings.Input.DIAMETER, [Input.Type.NUMBER]);
+          while (true) {
+            const diameter = await DesignCore.Scene.inputManager.requestInput(op3);
+            if (diameter === undefined) return;
+            if (diameter <= 0) {
+              DesignCore.Core.notify(`${this.type} - ${Strings.Error.NONZERO}`);
+              continue;
+            }
+            this.setRadius(diameter / 2);
+            break;
+          }
+          break;
+        }
       }
 
-      if (Input.getType(pt2) === Input.Type.NUMBER) {
-        this.setRadius(pt2);
-      }
       DesignCore.Scene.inputManager.executeCommand(this);
     } catch (err) {
       Logging.instance.error(`${this.type} - ${err}`);
     }
   }
 
+  /**
+   * 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 });
     }
   }
 
+  /**
+   * Get Circle radius
+   * @return {number} - circle radius
+   */
   getRadius() {
     return this.points[0].distance(this.points[1]);
   }
 
+  /**
+   * Set Circle radius
+   * @param {number} rad
+   */
   setRadius(rad) {
     this.points[1] = this.points[0].project(0, rad);
   }
 
+  /**
+   * 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, 0, 6.283);
     ctx.stroke();
   }
 
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
   dxf(file) {
     file.writeGroupCode('0', 'CIRCLE');
-    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);
+    file.writeGroupCode('6', this.lineType);
+    this.writeDxfColour(file);
     file.writeGroupCode('10', this.points[0].x);
     file.writeGroupCode('20', this.points[0].y);
     file.writeGroupCode('30', '0.0');
+    file.writeGroupCode('39', this.lineWidth);
     file.writeGroupCode('40', this.radius);
   }
 
-  trim(points) {
-    if (points.length > 1) {
-      const start = points[0];
-      const cen = DesignCore.Mouse.pointOnScene();
-      const end = points[1];
-
-      const arcPoints = [this.points[0]];
-
-      const dir = (start.x - cen.x) * (end.y - cen.y) - (start.y - cen.y) * (end.x - cen.x);
-      if (dir > 0) {
-        arcPoints.push(points[0], points[1]);
-      } else if (dir < 0) {
-        arcPoints.push(points[1], points[0]);
-      }
+  /**
+   * Return a list of points representing a polyline version of this entity
+   * @return {Array}
+   */
+  toPolylinePoints() {
+    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];
+  }
 
+  /**
+   * 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, center.project(0, radius)];
+  }
 
-      const data = {
-        points: arcPoints,
-        colour: this.colour,
-        layer: this.layer,
-        lineWidth: this.lineWidth,
-      };
+  /**
+   * 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;
+    }
 
-      DesignCore.Scene.addItem('Arc', data, DesignCore.Scene.items.indexOf(this));
+    const direction = 1; // Circle is always CCW for trimming purposes
+
+    // get the mouse position
+    const mousePosition = DesignCore.Mouse.pointOnScene();
+    // get the point on the arc closest to the mouse
+    const pointOnCircle = mousePosition.closestPointOnArc(this.points[1], this.points[1], this.points[0]);
+    // sort intersection points
+    Utils.sortPointsOnArc(intersections, this.points[0], this.points[0], this.points[0], direction);
+    // Repeat the first point to close the circle
+    const testPoints = [...intersections, intersections.at(0)]; // Closing the circle
+
+    // 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 (pointOnCircle.isOnArc(startPoint, endPoint, this.points[0], direction)) {
+          // create a new arc entity
+          const arc = DesignCore.CommandManager.createNew('Arc', this);
+          arc.handle = undefined;
+          // flip direction
+          arc.direction = direction * -1;
+          arc.points = [this.points[0], startPoint, endPoint];
+          const addState = new AddState(arc);
+          stateChanges.push(addState);
+
+          // Remove the existing arc
+          if (stateChanges.length > 0) {
+            const removeState = new RemoveState(this);
+            stateChanges.push(removeState);
+            return stateChanges;
+          }
+        }
+      }
     }
-  }
 
-  intersectPoints() {
-    return {
-      centre: this.points[0],
-      radius: this.radius,
-    };
+    return stateChanges;
   }
 
+  /**
+   * Get snap points
+   * @param {Point} mousePoint
+   * @param {number} delta
+   * @return {Array} - array of snap points
+   */
   snaps(mousePoint, delta) {
     const snaps = [];
 
@@ -154,6 +272,11 @@ export class Circle extends Entity {
     return snaps;
   }
 
+  /**
+   * Get closest point on entity
+   * @param {Point} P
+   * @return {Array} - [Point, distance]
+   */
   closestPoint(P) {
     // find the closest point on the circle
     const closest = P.closestPointOnArc(this.points[1], this.points[1], this.points[0]);
@@ -162,6 +285,10 @@ export class Circle extends Entity {
     return [closest, distance];
   }
 
+  /**
+   * Return boundingbox for entity
+   * @return {BoundingBox}
+   */
   boundingBox() {
     const xmin = this.points[0].x - this.radius;
     const xmax = this.points[0].x + this.radius;

package/core/entities/entity.js

@@ -1,11 +1,22 @@
-import {Colours} from '../lib/colours.js';
-import {Intersection} from '../lib/intersect.js';
-import {Point} from './point.js';
-import {Strings} from '../lib/strings.js';
+import { Colours } from '../lib/colours.js';
+import { EntityColour } from '../lib/colour.js';
+import { Intersection } from '../lib/intersect.js';
+import { Point } from './point.js';
+import { Strings } from '../lib/strings.js';
+import { Property } from '../properties/property.js';
 
-import {DesignCore} from '../designCore.js';
 
+import { DesignCore } from '../designCore.js';
+
+/**
+ * Entity Class
+ * @extend Entity
+ */
 export class Entity {
+  /**
+   * Create a Entity
+   * @param {Array} data
+   */
   constructor(data) {
     Object.defineProperty(this, 'type', {
       value: this.constructor.name,
@@ -17,33 +28,52 @@ export class Entity {
       writable: true,
     });
 
-    /*
-    Object.defineProperty(this, 'trueColour', {
-      //enumerable: false,
+    Object.defineProperty(this, 'colour', {
+      get: this.getColour,
+      set: this.setColour,
+    });
+
+    Object.defineProperty(this, 'entityColour', {
+      value: new EntityColour(),
       writable: true,
     });
-    */
 
     this.lineWidth = 2;
-    this.colour = 'BYLAYER';
-    this.lineType = 'BYLAYER';
+    this.lineType = 'ByLayer';
     this.layer = '0';
 
+    // DXF Groupcode 5 - Handle
+    Object.defineProperty(this, 'handle', {
+      value: Property.loadValue([data?.handle, data?.[5]]),
+      writable: true,
+    });
+    // DXF Groupcode 6 - lineType
+    this.lineType = Property.loadValue([data?.lineType, data?.[6]], 'ByLayer');
+    // DXF Groupcode 39 - Thickness (lineWidth)
+    this.lineWidth = Property.loadValue([data?.lineWidth, data?.[39]], 2);
+    // DXF Groupcode 8 - layername
+    this.layer = Property.loadValue([data?.layer, data?.[8]], '0');
 
     if (data) {
-      if (data.points) {
+      if (data.hasOwnProperty('points')) {
         this.points = data.points;
       }
 
-      if (data.colour || data[62]) {
-        // DXF Groupcode 62 - Color Number
-        // (present if not BYLAYER); zero indicates the BYBLOCK
-        // (floating) color; 256 indicates BYLAYER; a negative value indicates that
-        // the layer is turned off (optional)
-        this.colour = data.colour || Colours.getHexColour(data[62]);
+      if (data.hasOwnProperty('colour') || data.hasOwnProperty('62')) {
+        // DXF Groupcode 62 - Color Number (present if not BYLAYER)(optional);
+        // zero indicates BYBLOCK
+        // 256 indicates BYLAYER;
+        // a negative value indicates that the layer is turned off
+        if (data.colour) {
+          if (Colours.isRGB(data.colour)) {
+            this.colour = data.colour;
+          }
+        } else if (data.hasOwnProperty('62')) {
+          this.entityColour.setColourFromACI(Math.abs(data[62]));
+        }
       }
 
-      if (data.trueColour || data[420]) {
+      if (data.hasOwnProperty('trueColour') || data.hasOwnProperty('420')) {
         // DXF Groupcode 420 - true color
         // A 24-bit color value that should be dealt with in terms of bytes with values
         // of 0 to 255. The lowest byte is the blue value, the middle byte is the
@@ -51,66 +81,94 @@ export class Entity {
         // 0. The group code cannot be used by custom entities for their own data
         // because the group code is reserved for AcDbEntity, class-level color data
         // and AcDbEntity, class-level transparency data
-        // this.trueColour = data.trueColour;
-        const err = 'Groupcode 420 not implemented';
-        Logging.instance.warn(`${this.type} - ${err}`);
-      }
 
-
-      if (data.lineType || data[6]) {
-        // DXF Groupcode 6 - lineType
-        this.lineType = data.lineType || data[6];
-      }
-
-      if (data.layer || data[8]) {
-        // DXF Groupcode 8 - layername
-        this.layer = data.layer || data[8];
+        const trueColour = Colours.trueColourToRGB(data.trueColour || data[420]);
+        if (trueColour) {
+          this.colour = trueColour;
+        }
       }
     }
   }
 
+
+  /**
+   * get rgb colour
+   * @return {number} rgb colour object
+   */
   getColour() {
-    // if (this.trueColour !== undefined) {
-    //   return this.trueColour;
-    // }
+    return this.entityColour.getColour(); ;
+  }
 
-    let colour = this.colour;
+  /**
+   * get rgb colour to draw
+   * @return {number} rgb colour object
+   */
+  getDrawColour() {
+    let rgb = this.getColour();
 
-    if (colour === 'BYLAYER') {
-      const layer = DesignCore.LayerManager.getStyleByName(this.layer);
-      colour = layer.colour;
+    if (this.entityColour.byLayer) {
+      const layer = DesignCore.LayerManager.getItemByName(this.layer);
+      rgb = layer?.colour;
     }
 
-    return colour;
+    return rgb;
   }
 
+  /**
+   * Set the entity colour
+   * @param {Object} rgb
+   */
+  setColour(rgb) {
+    this.entityColour.setColour(rgb);
+  }
+
+  /**
+   * Get the line type
+   * @return {LType}
+   */
   getLineType() {
     let lineTypeName = this.lineType;
 
-    if (lineTypeName === 'BYLAYER') {
-      const layer = DesignCore.LayerManager.getStyleByName(this.layer);
-      lineTypeName = layer.lineType;
+    if (lineTypeName.toUpperCase() === 'BYLAYER') {
+      const layer = DesignCore.LayerManager.getItemByName(this.layer);
+      lineTypeName = layer?.lineType;
     }
 
-    const lineType = DesignCore.LTypeManager.getStyleByName(lineTypeName);
+    const lineType = DesignCore.LTypeManager.getItemByName(lineTypeName);
 
     return lineType;
   }
 
+  /**
+   * Write the colour to file in the dxf format
+   * @param {DXFFile} file
+   */
+  writeDxfColour(file) {
+    if (this.entityColour.aci != 256) {
+      file.writeGroupCode('62', this.entityColour.aci);
+    }
+    if (this.entityColour.isTrueColour) {
+      file.writeGroupCode('420', Colours.rgbToTrueColour(this.colour));
+    }
+  }
 
-  within(selectionExtremes) {
-    const layer = DesignCore.LayerManager.getStyleByName(this.layer);
+  /**
+   * Determine if the entity is within the selection
+   * @param {Object} selection - {min: Point, max: Point}
+   * @return {boolean} true if within
+   */
+  within(selection) {
+    const layer = DesignCore.LayerManager.getItemByName(this.layer);
 
-    if (!layer.isSelectable) {
+    if (!layer?.isSelectable) {
       return;
     }
 
-    // determin if this entities is within a the window specified by selectionExtremes
     const boundingBox = this.boundingBox();
-    if ( boundingBox.xMin > selectionExtremes[0] &&
-          boundingBox.xMax < selectionExtremes[1] &&
-          boundingBox.yMin > selectionExtremes[2] &&
-          boundingBox.yMax < selectionExtremes[3]
+    if (boundingBox.xMin > selection.min.x &&
+      boundingBox.xMax < selection.max.x &&
+      boundingBox.yMin > selection.min.y &&
+      boundingBox.yMax < selection.max.y
     ) {
       return true;
     }
@@ -118,43 +176,65 @@ export class Entity {
     return false;
   }
 
-  touched(selectionExtremes) {
-    const layer = DesignCore.LayerManager.getStyleByName(this.layer);
+  /**
+   * Determine if the entity is touch the selection window
+   * @param {Object} selection - {min: Point, max: Point}
+   * @return {boolean} true if touched
+   */
+  touched(selection) {
+    const layer = DesignCore.LayerManager.getItemByName(this.layer);
 
-    if (!layer.isSelectable) {
+    if (!layer?.isSelectable) {
       return;
     }
 
-    const rP1 = new Point(selectionExtremes[0], selectionExtremes[2]);
-    const rP2 = new Point(selectionExtremes[1], selectionExtremes[3]);
-
-    const rectPoints = {
-      start: rP1,
-      end: rP2,
-    };
+    const rectPoints = [
+      selection.min,
+      new Point(selection.max.x, selection.min.y),
+      selection.max,
+      new Point(selection.min.x, selection.max.y),
+      selection.min,
+    ];
 
-    const intersectFunction = `intersect${this.type}Rectangle`;
+    const output = Intersection.intersectPolylinePolyline(this.toPolylinePoints(), rectPoints);
 
-    if (Intersection.hasOwnProperty(intersectFunction) === false) {
-      const msg = `${Strings.Error.INVALIDINTERSECTTYPE}: ${this.type}`;
-      DesignCore.Core.notify(msg);
-      throw Error(msg);
-    }
-
-    const output = Intersection[intersectFunction](this.intersectPoints(), rectPoints);
-
-    if (output.status === 'Intersection') {
+    if (output.status === Intersection.Status.INTERSECTION) {
       return true;
     }
     // no intersection found. return false
     return false;
   }
 
+  /**
+   * Extend the entity
+   * @param {Array} points
+   * @return {Array} - array of state changes
+   */
   extend(points) {
-    // extend function to be overidden by implementation
+    // extend function to be overridden by implementation
+    DesignCore.Core.notify(`${this.type} - ${Strings.Message.NOEXTEND}`);
+    return [];
   }
 
+  /**
+   * Trim the entity
+   * @param {Array} points
+   * @return {Array} - array of state changes
+   */
   trim(points) {
-    // trim function to be overidden by implementation
+    // trim function to be overridden by implementation
+    DesignCore.Core.notify(`${this.type} - ${Strings.Message.NOTRIM}`);
+    return [];
+  }
+
+  /**
+   * Set a property if it exists
+   * @param {string} property
+   * @param {any} value
+   */
+  setProperty(property, value) {
+    if (this.hasOwnProperty(property)) {
+      this[property] = value;
+    }
   }
 }