@design-core/core 0.0.1 → 0.0.3

package/core/entities/point.js

@@ -1,20 +1,27 @@
+import { Utils } from '../lib/utils.js';
+import { Constants } from '../lib/constants.js';
+
+/** Point Entity Class */
 export class Point {
   /**
-   * @param  {Number} x
+   * Create a Point
+   * @param  {number} x
    * @param  {number} y
+   * @param  {number} bulge
+   * @param  {number} sequence - dxf group code sequence reference
    */
-  constructor(x, y) {
+  constructor(x, y, bulge = 0, sequence) {
     this.type = this.constructor.name;
     this.x = 0;
     this.y = 0;
     // sequence holds a reference to the dxf group code sequence the point represents
     // 10, 20, 30;
     // 11, 21, 31;
-    this.sequence;
+    this.sequence = sequence;
 
     // bulge value used for defining arcs in polylines
     // arc is ccw if positive
-    this.bulge = 0;
+    this.bulge = bulge;
 
     if (x !== undefined) {
       this.x = x;
@@ -25,39 +32,44 @@ export class Point {
   /**
    * Add this to that
    * @param  {Point} that
+   * @return {Point}
    */
   add(that) {
-    return new Point(this.x + that.x, this.y + that.y);
+    return new Point(this.x + that.x, this.y + that.y, this.bulge, this.sequence);
   }
 
   /**
    * subtract that from this
    * @param  {Point} that
+   * @return {Point}
    */
   subtract(that) {
-    return new Point(this.x - that.x, this.y - that.y);
+    return new Point(this.x - that.x, this.y - that.y, this.bulge, this.sequence);
   };
 
   /**
    * Angle between this and that in radians
    * @param  {Point} that
+   * @return {number}
    */
   angle(that) {
     const angle = Math.atan2((this.y - that.y), (this.x - that.x)) + Math.PI;
-    return angle % (Math.PI*2);
+    return angle % (Math.PI * 2);
   }
 
 
   /**
    * Returns a deep clone of a point
+   * @return {Point}
    */
   clone() {
-    return new Point(this.x, this.y);
+    return new Point(this.x, this.y, this.bulge, this.sequence);
   };
 
   /**
    * Returns distance between this and that
    * @param  {Point} that
+   * @return {number}
    */
   distance(that) {
     return Math.sqrt((this.x - that.x) * (this.x - that.x) + (this.y - that.y) * (this.y - that.y));
@@ -66,26 +78,100 @@ export class Point {
 
   /**
    * Return dot product of this and that
+   * Measures how much two vectors point in the same direction.
+   * Equal to |this| * |that| * cos(angle between them).
+   * Positive: vectors point in the same direction (angle < 90°)
+   * Zero: vectors are perpendicular (angle = 90°)
+   * Negative: vectors point in opposite directions (angle > 90°)
    * @param  {Point} that
+   * @return {number}
    */
   dot(that) {
     return this.x * that.x + this.y * that.y;
   };
 
+  /**
+   * Return 2D cross product of this and that
+   * Measures the signed area of the parallelogram formed by the two vectors.
+   * Equal to |this| * |that| * sin(angle from this to that).
+   * Positive: that is counter-clockwise from this
+   * Zero: vectors are parallel (or one is zero length)
+   * Negative: that is clockwise from this
+   * @param  {Point} that
+   * @return {number}
+   */
+  cross(that) {
+    return this.x * that.y - this.y * that.x;
+  };
+
+  /**
+   * Return new point mirrored across the line defined by pt1 and pt2
+   * @param  {Point} pt1 - first point on the mirror line
+   * @param  {Point} pt2 - second point on the mirror line
+   * @return {Point}
+   */
+  mirror(pt1, pt2) {
+    if (pt1.isSame(pt2)) return this.clone();
+    const perp = this.perpendicular(pt1, pt2);
+    return new Point(2 * perp.x - this.x, 2 * perp.y - this.y, -this.bulge, this.sequence);
+  }
+
+  /**
+   * Return new point scaled from base by a scalar factor
+   * @param  {Point} base
+   * @param  {number} factor
+   * @return {Point}
+   */
+  scaleFrom(base, factor) {
+    const x = base.x + (this.x - base.x) * factor;
+    const y = base.y + (this.y - base.y) * factor;
+    return new Point(x, y, this.bulge, this.sequence);
+  }
+
   /**
    * Return new point rotated about centre by angle in radians
    * @param  {Point} centre
-   * @param  {Number} angle - in radians
+   * @param  {number} angle - in radians
+   * @return {Point}
    */
   rotate(centre, angle) {
     const x = centre.x + (this.x - centre.x) * Math.cos(angle) - (this.y - centre.y) * Math.sin(angle);
     const y = centre.y + (this.x - centre.x) * Math.sin(angle) + (this.y - centre.y) * Math.cos(angle);
-    return new Point(x, y);
+    return new Point(x, y, this.bulge, this.sequence);
+  }
+
+  /**
+   * Return the length (magnitude) of this vector.
+   * @return {number}
+   */
+  length() {
+    return Math.sqrt(this.x ** 2 + this.y ** 2);
+  }
+
+  /**
+   * Return a new unit vector in the same direction as this.
+   * (Divides each component by the vector's magnitude.)
+   * @return {Point}
+   */
+  normalise() {
+    const len = this.length();
+    if (len < Constants.Tolerance.EPSILON) return new Point(0, 0);
+    return new Point(this.x / len, this.y / len);
+  }
+
+  /**
+   * Return a new point scaled by a scalar factor.
+   * @param  {number} scalar
+   * @return {Point}
+   */
+  scale(scalar) {
+    return new Point(this.x * scalar, this.y * scalar);
   }
 
   /**
    * Return new point with minimum values for x and y from this and that
    * @param  {Point} that
+   * @return {Point}
    */
   min(that) {
     return new Point(
@@ -97,6 +183,7 @@ export class Point {
   /**
    * Return new point with maximum values for x and y from this and that
    * @param  {Point} that
+   * @return {Point}
    */
   max(that) {
     return new Point(
@@ -108,6 +195,7 @@ export class Point {
   /**
    * Return midpoint between this and that
    * @param  {Point} that
+   * @return {Point}
    */
   midPoint(that) {
     // return point midway between this and that
@@ -123,7 +211,8 @@ export class Point {
    * Returns linear interpolation between this and that
    * e.g. t = 0.5 will return midpoint between this and that
    * @param  {Point} that
-   * @param  {Number} t - ratio between 0 and 1
+   * @param  {number} t - ratio between 0 and 1
+   * @return {Point}
    */
   lerp(that, t) {
     return new Point(
@@ -134,8 +223,9 @@ export class Point {
 
   /**
    * Return new point projected from this along angle by distance
-   * @param  {Number} angle - in radians
-   * @param  {Number} distance
+   * @param  {number} angle - in radians
+   * @param  {number} distance
+   * @return {Point}
    */
   project(angle, distance) {
     if (angle === 0) {
@@ -153,7 +243,7 @@ export class Point {
    * Find the closest point to this on the ray formed by Pt1 and Pt2
    * @param  {Point} Pt1
    * @param  {Point} Pt2
-   * @returns the closest point on the ray
+   * @return {Point} the closest point on the ray
    */
   perpendicular(Pt1, Pt2) {
     const APx = this.x - Pt1.x;
@@ -162,6 +252,7 @@ export class Point {
     const ABy = Pt2.y - Pt1.y;
 
     const magAB2 = ABx * ABx + ABy * ABy;
+    if (magAB2 === 0) return new Point(Pt1.x, Pt1.y);
     const ABdotAP = ABx * APx + ABy * APy;
     const t = ABdotAP / magAB2;
 
@@ -173,17 +264,18 @@ export class Point {
   /**
    * Check if this is the same as that
    * @param  {Point} that
+   * @return {boolean}
    */
   isSame(that) {
-    if (this.x == that.x && this.y == that.y) return true;
+    if (Utils.round(this.x) == Utils.round(that.x) && Utils.round(this.y) == Utils.round(that.y)) return true;
     return false;
   }
 
   /**
    * Find the closest point on a line between start and end points
-   * @param {*} startPoint
-   * @param {*} endPoint
-   * @returns the closest point on the line or null
+   * @param {Point} startPoint
+   * @param {Point} endPoint
+   * @return {Point} the closest point on the line
    */
   closestPointOnLine(startPoint, endPoint) {
     const pnt = this.perpendicular(startPoint, endPoint);
@@ -191,7 +283,13 @@ export class Point {
       return pnt;
     }
 
-    return null;
+    // point is not perpendicular to the line
+    // closest point must be at the start or end
+    if (this.distance(startPoint) < this.distance(endPoint)) {
+      return startPoint;
+    } else {
+      return endPoint;
+    }
   }
 
   /**
@@ -200,9 +298,9 @@ export class Point {
    * @param {Point} endPoint
    * @param {Point} centerPoint
    * @param {number} direction - CCW if > 0
-   * @returns the closest point on the arc or null
+   * @return {Point} the closest point on the arc or null
    */
-  closestPointOnArc(startPoint, endPoint, centerPoint, direction=1) {
+  closestPointOnArc(startPoint, endPoint, centerPoint, direction = 0) {
     const length = this.distance(centerPoint);
     const radius = centerPoint.distance(startPoint);
 
@@ -229,14 +327,16 @@ export class Point {
    * @param {Point} endPoint
    * @param {Point} centerPoint
    * @param {number} direction - CCW if > 0
-   * @returns true or false
+   * @return {Point} true or false
    */
-  isOnArc(startPoint, endPoint, centerPoint, direction=1) {
+  isOnArc(startPoint, endPoint, centerPoint, direction = 0) {
+    // direction: ccw arc > 0, clockwise arc <= 0
     const snapAngle = centerPoint.angle(this);
     const startAngle = centerPoint.angle(startPoint);
     const endAngle = centerPoint.angle(endPoint);
 
     if (direction > 0) {
+      // Counter Clockwise Arc
       if (startAngle < endAngle) {
         if (snapAngle >= startAngle && snapAngle <= endAngle) {
           return true;
@@ -248,7 +348,8 @@ export class Point {
           return true;
         }
       }
-    } else if (direction < 0) {
+    } else if (direction <= 0) {
+      // Clockwise Arc
       if (startAngle < endAngle) {
         if (snapAngle <= startAngle || snapAngle >= endAngle) {
           return true;
@@ -270,19 +371,51 @@ export class Point {
    * Determine if point is on line segment
    * @param {Point} startPoint
    * @param {Point} endPoint
-   * @returns true or false
+   * @return {Point} true or false
    */
   isOnLine(startPoint, endPoint) {
     // check start -> point + point -> end equals start -> end
-    if (startPoint.distance(this) + this.distance(endPoint) === startPoint.distance(endPoint)) {
+    if (Utils.round(startPoint.distance(this) + this.distance(endPoint)) === Utils.round(startPoint.distance(endPoint))) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if point is inside rectangle defined by points A, B, C, D
+   * @param {Point} A - Bottom left rectangle corner
+   * @param {Point} B - Bottom right rectangle corner
+   * @param {Point} C - Top right rectangle corner
+   * @param {Point} D - Top left rectangle corner
+   * @return {boolean} - true if point is inside rectangle
+   */
+  isInRectangle(A, B, C, D) {
+    /* Calculate area of rectangle ABCD */
+    const rectangleArea = Utils.areaOfTriangle(A, B, C) + Utils.areaOfTriangle(A, C, D);
+
+    /* Calculate area of triangle PAB */
+    const A1 = Utils.areaOfTriangle(this, A, B);
+
+    /* Calculate area of triangle PBC */
+    const A2 = Utils.areaOfTriangle(this, B, C);
+
+    /* Calculate area of triangle PCD */
+    const A3 = Utils.areaOfTriangle(this, C, D);
+
+    /* Calculate area of triangle PAD */
+    const A4 = Utils.areaOfTriangle(this, A, D);
+
+    /* Check if sum of A1, A2, A3 and A4 is same as A */
+    if (Utils.round(rectangleArea) === Utils.round(A1 + A2 + A3 + A4)) {
       return true;
     }
+
     return false;
   }
 
   /**
    * Get the arc angle in radians from the bulge value
-   * @returns arc angle in radians
+   * @return {Point} arc angle in radians
    */
   bulgeAngle() {
     return Math.atan(this.bulge) * 4;
@@ -290,6 +423,8 @@ export class Point {
 
   /**
    * Return the radius of the arc from the next point in the polyline
+   * @param {Point} nextPoint
+   * @return {number}
    */
   bulgeRadius(nextPoint) {
     if (this.bulge == 0) {
@@ -303,7 +438,7 @@ export class Point {
   /**
    * Returns apothem; the distance from arc center to cord midpoint
    * @param {Point} nextPoint
-   * @returns apothem
+   * @return {number} apothem
    */
   apothem(nextPoint) {
     if (this.bulge == 0) {
@@ -317,7 +452,7 @@ export class Point {
   /**
    * Return the centre point of the arc
    * @param {Point} nextPoint
-   * @returns Point
+   * @return {Point} Point
    */
   bulgeCentrePoint(nextPoint) {
     const midp = this.midPoint(nextPoint);
@@ -340,4 +475,34 @@ export class Point {
 
     return centre;
   }
+
+  /**
+   * Calculate the bulge for a partial arc segment
+   * @param {Point} nextPoint - segment end point
+   * @param {Point} splitPoint - point where the arc is split
+   * @param {boolean} afterSplit - if true, return bulge for the portion after the split point
+   * @return {number} - the partial bulge value
+   */
+  partialBulge(nextPoint, splitPoint, afterSplit = false) {
+    const center = this.bulgeCentrePoint(nextPoint);
+    const direction = this.bulge > 0 ? 1 : -1;
+
+    const startAngle = center.angle(this);
+    const endAngle = center.angle(nextPoint);
+    const splitAngle = center.angle(splitPoint);
+
+    let includedAngle;
+    if (afterSplit) {
+      // Angle from split point to end
+      includedAngle = (endAngle - splitAngle) * direction;
+    } else {
+      // Angle from start to split point
+      includedAngle = (splitAngle - startAngle) * direction;
+    }
+
+    // Normalise to 0..2PI
+    includedAngle = ((includedAngle % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
+
+    return Math.tan(includedAngle / 4) * direction;
+  }
 }

package/core/entities/polyline.js

@@ -1,15 +1,24 @@
-import {BasePolyline} from './basePolyline.js';
-import {Point} from './point.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { BasePolyline } from './basePolyline.js';
+import { Point } from './point.js';
 
+/**
+ * Polyline Entity Class
+ * @extends BasePolyline
+ */
 export class Polyline extends BasePolyline {
+  /**
+   * Create a Polyline
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
 
     if (data) {
-      if (data.children) {
-      // remove any points
-      // point data comes from the vertices
-        if (data.points) {
+      if (data.hasOwnProperty('children')) {
+        // remove any points
+        // point data comes from the vertices
+        if (data.hasOwnProperty('points')) {
           this.points = [];
         }
 
@@ -28,8 +37,46 @@ export class Polyline extends BasePolyline {
     }
   }
 
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
+  dxf(file) {
+    if (file.version < DXFFile.Version.R2000) {
+      // POLYLINE/VERTEX/SEQEND format for R12
+      file.writeGroupCode('0', 'POLYLINE');
+      file.writeGroupCode('8', this.layer);
+      file.writeGroupCode('6', this.lineType);
+      file.writeGroupCode('66', 1); // vertices-follow flag
+      file.writeGroupCode('70', this.flags.getFlagValue());
+
+      for (let i = 0; i < this.points.length; i++) {
+        file.writeGroupCode('0', 'VERTEX');
+        file.writeGroupCode('8', this.layer);
+        file.writeGroupCode('10', this.points[i].x);
+        file.writeGroupCode('20', this.points[i].y);
+        file.writeGroupCode('30', '0.0');
+        file.writeGroupCode('42', this.points[i].bulge);
+      }
+
+      file.writeGroupCode('0', 'SEQEND');
+      file.writeGroupCode('8', this.layer);
+      return;
+    }
+
+    // Default to LWPOLYLINE output for R2000 and later
+    super.dxf(file);
+  }
+
+  /**
+   * 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: 'Polyline', shortcut: 'PL', type: 'Entity'};
+    const command = { command: 'Polyline', shortcut: 'PL', type: 'Entity' };
     return command;
   }
 }

package/core/entities/rectangle.js

@@ -1,36 +1,57 @@
-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 {Polyline} from './polyline.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 { Polyline } from './polyline.js';
 
-import {DesignCore} from '../designCore.js';
+import { DesignCore } from '../designCore.js';
 
+/**
+ * Rectangle Entity Class
+ * @extends Entity
+ */
 export class Rectangle extends Entity {
+  /**
+   * Create a Rectangle
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
     // There is no DXF representation of a Rectangle
     // Convenience entity to create a polyline from two points
   }
 
+  /**
+   * 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: 'Rectangle', shortcut: 'REC', type: 'Entity'};
+    const command = { command: 'Rectangle', shortcut: 'REC', 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);
 
       const op2 = new PromptOptions(Strings.Input.END, [Input.Type.POINT]);
       const pt2 = await DesignCore.Scene.inputManager.requestInput(op2);
+      if (pt2 === undefined) return;
       this.points.push(pt2);
 
       const points = this.rectPoints(this.points[0], this.points[1]);
-      const polyline = new Polyline({points: points});
+      const polyline = new Polyline({ points: points });
 
       DesignCore.Scene.inputManager.executeCommand(polyline);
     } catch (err) {
@@ -38,20 +59,29 @@ export class Rectangle extends Entity {
     }
   }
 
+  /**
+   * Preview the entity during creation
+   */
   preview() {
     if (this.points.length >= 1) {
       const mousePoint = DesignCore.Mouse.pointOnScene();
       const points = this.rectPoints(this.points.at(-1), mousePoint);
-      DesignCore.Scene.createTempItem('Polyline', {points: points});
+      DesignCore.Scene.tempEntities.create('Polyline', { points: points });
     }
   }
 
+  /**
+   * Get the rectangle points
+   * @param {Point} pt1
+   * @param {Point} pt2
+   * @return {Array} array of points for each corner
+   */
   rectPoints(pt1, pt2) {
     const points = [];
-    points.push( new Point(pt1.x, pt1.y));
+    points.push(new Point(pt1.x, pt1.y));
     points.push(new Point(pt2.x, pt1.y));
-    points.push( new Point(pt2.x, pt2.y));
-    points.push( new Point(pt1.x, pt2.y));
+    points.push(new Point(pt2.x, pt2.y));
+    points.push(new Point(pt1.x, pt2.y));
     points.push(new Point(pt1.x, pt1.y));
     return points;
   }

package/core/entities/solid.js

@@ -1,12 +1,25 @@
-import {Entity} from './entity.js';
-import {DXFFile} from '../lib/dxf/dxfFile.js';
-import {BoundingBox} from '../lib/boundingBox.js';
+import { Entity } from './entity.js';
+import { DXFFile } from '../lib/dxf/dxfFile.js';
+import { BoundingBox } from '../lib/boundingBox.js';
 
+/**
+ * Solid Entity Class
+ * @extends Entity
+ */
 export class Solid extends Entity {
+  /**
+   * Create a Solid Entity
+   * @param {Array} data
+   */
   constructor(data) {
     super(data);
   }
 
+  /**
+   * Draw the entity
+   * @param {Object} ctx - context
+   * @param {number} scale
+   */
   draw(ctx, scale) {
     this.points.forEach((point, index) => {
       if (index == 0) {
@@ -20,9 +33,13 @@ export class Solid extends Entity {
     ctx.fill();
   }
 
+  /**
+   * Write the entity to file in the dxf format
+   * @param {DXFFile} file
+   */
   dxf(file) {
     file.writeGroupCode('0', 'SOLID');
-    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', 'AcDbTrace', DXFFile.Version.R2000);
     file.writeGroupCode('8', this.layer);
@@ -39,15 +56,35 @@ export class Solid extends Entity {
     file.writeGroupCode('32', '0.0');
 
     // If only three points are use to define the SOLID then the fourth points is the same as the third.
-    file.writeGroupCode('13', this.points[3].x || this.points[2].x);
-    file.writeGroupCode('23', this.points[3].y || this.points[2].x);
+    file.writeGroupCode('13', this.points.length > 3 ? this.points[3].x : this.points[2].x);
+    file.writeGroupCode('23', this.points.length > 3 ? this.points[3].y : this.points[2].x);
     file.writeGroupCode('33', '0.0');
   }
 
+  /**
+   * Get closest point on entity
+   * @param {Point} P
+   * @return {Array} - [Point, distance]
+   */
   closestPoint(P) {
     return [P, Infinity];
   }
 
+  /**
+   * Convert the entity to polyline points
+   * @return {Array} array of points representing the solid as a polyline
+   */
+  toPolylinePoints() {
+    const points = this.points.map((point) => point.clone());
+    // Close the shape
+    points.push(this.points[0].clone());
+    return points;
+  }
+
+  /**
+   * Return boundingbox for entity
+   * @return {BoundingBox}
+   */
   boundingBox() {
     return BoundingBox.fromPoints(this.points);
   }