@js-draw/math 1.2.2 → 1.3.0

package/dist/cjs/Color4.d.ts

@@ -12,7 +12,7 @@ import Vec3 from './Vec3';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-export default class Color4 {
+export declare class Color4 {
     /** Red component. Should be in the range [0, 1]. */
     readonly r: number;
     /** Green component. ${\tt g} \in [0, 1]$ */
@@ -120,4 +120,4 @@ export default class Color4 {
     static gray: Color4;
     static white: Color4;
 }
-export { Color4 };
+export default Color4;

package/dist/cjs/shapes/Path.d.ts

@@ -53,6 +53,13 @@ export declare class Path {
     getExactBBox(): Rect2;
     private cachedGeometry;
     get geometry(): GeometryArrayType;
+    /**
+     * Iterates through the start/end points of each component in this path.
+     *
+     * If a start point is equivalent to the end point of the previous segment,
+     * the point is **not** emitted twice.
+     */
+    startEndPoints(): Generator<import("../Vec3").Vec3, undefined, unknown>;
     private cachedPolylineApproximation;
     polylineApproximation(): LineSegment2[];
     static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;

package/dist/cjs/shapes/Path.js

@@ -51,6 +51,7 @@ class Path {
         let startPoint = this.startPoint;
         const geometry = [];
         for (const part of this.parts) {
+            let exhaustivenessCheck;
             switch (part.kind) {
                 case PathCommandType.CubicBezierTo:
                     geometry.push(new CubicBezier_1.default(startPoint, part.controlPoint1, part.controlPoint2, part.endPoint));
@@ -68,11 +69,43 @@ class Path {
                     geometry.push(new PointShape2D_1.default(part.point));
                     startPoint = part.point;
                     break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
             }
         }
         this.cachedGeometry = geometry;
         return this.cachedGeometry;
     }
+    /**
+     * Iterates through the start/end points of each component in this path.
+     *
+     * If a start point is equivalent to the end point of the previous segment,
+     * the point is **not** emitted twice.
+     */
+    *startEndPoints() {
+        yield this.startPoint;
+        for (const part of this.parts) {
+            let exhaustivenessCheck;
+            switch (part.kind) {
+                case PathCommandType.CubicBezierTo:
+                    yield part.endPoint;
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    yield part.endPoint;
+                    break;
+                case PathCommandType.LineTo:
+                    yield part.point;
+                    break;
+                case PathCommandType.MoveTo:
+                    yield part.point;
+                    break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
+            }
+        }
+    }
     // Approximates this path with a group of line segments.
     polylineApproximation() {
         if (this.cachedPolylineApproximation) {

package/dist/cjs/shapes/Rect2.d.ts

@@ -19,7 +19,6 @@ export declare class Rect2 extends Abstract2DShape {
     readonly h: number;
     readonly topLeft: Point2;
     readonly size: Vec2;
-    readonly bottomRight: Point2;
     readonly area: number;
     constructor(x: number, y: number, w: number, h: number);
     translatedBy(vec: Vec2): Rect2;
@@ -35,6 +34,7 @@ export declare class Rect2 extends Abstract2DShape {
     getClosestPointOnBoundaryTo(target: Point2): Vec3;
     get corners(): Point2[];
     get maxDimension(): number;
+    get bottomRight(): Vec3;
     get topRight(): Vec3;
     get bottomLeft(): Vec3;
     get width(): number;

package/dist/cjs/shapes/Rect2.js

@@ -26,7 +26,6 @@ class Rect2 extends Abstract2DShape_1.default {
         // Precompute/store vector forms.
         this.topLeft = Vec2_1.Vec2.of(this.x, this.y);
         this.size = Vec2_1.Vec2.of(this.w, this.h);
-        this.bottomRight = this.topLeft.plus(this.size);
         this.area = this.w * this.h;
     }
     translatedBy(vec) {
@@ -42,8 +41,8 @@ class Rect2 extends Abstract2DShape_1.default {
     }
     containsRect(other) {
         return this.x <= other.x && this.y <= other.y
-            && this.bottomRight.x >= other.bottomRight.x
-            && this.bottomRight.y >= other.bottomRight.y;
+            && this.x + this.w >= other.x + other.w
+            && this.y + this.h >= other.y + other.h;
     }
     intersects(other) {
         // Project along x/y axes.
@@ -116,6 +115,12 @@ class Rect2 extends Abstract2DShape_1.default {
         if (margin === 0) {
             return this;
         }
+        // Prevent width/height from being negative
+        if (margin < 0) {
+            const xMargin = -Math.min(-margin, this.w / 2);
+            const yMargin = -Math.min(-margin, this.h / 2);
+            return new Rect2(this.x - xMargin, this.y - yMargin, this.w + xMargin * 2, this.h + yMargin * 2);
+        }
         return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
     }
     getClosestPointOnBoundaryTo(target) {
@@ -144,6 +149,9 @@ class Rect2 extends Abstract2DShape_1.default {
     get maxDimension() {
         return Math.max(this.w, this.h);
     }
+    get bottomRight() {
+        return this.topLeft.plus(this.size);
+    }
     get topRight() {
         return this.bottomRight.plus(Vec2_1.Vec2.of(0, -this.h));
     }
@@ -234,16 +242,16 @@ class Rect2 extends Abstract2DShape_1.default {
             return Rect2.empty;
         }
         const firstRect = rects[0];
-        let minX = firstRect.topLeft.x;
-        let minY = firstRect.topLeft.y;
-        let maxX = firstRect.bottomRight.x;
-        let maxY = firstRect.bottomRight.y;
+        let minX = firstRect.x;
+        let minY = firstRect.y;
+        let maxX = firstRect.x + firstRect.w;
+        let maxY = firstRect.y + firstRect.h;
         for (let i = 1; i < rects.length; i++) {
             const rect = rects[i];
-            minX = Math.min(minX, rect.topLeft.x);
-            minY = Math.min(minY, rect.topLeft.y);
-            maxX = Math.max(maxX, rect.bottomRight.x);
-            maxY = Math.max(maxY, rect.bottomRight.y);
+            minX = Math.min(minX, rect.x);
+            minY = Math.min(minY, rect.y);
+            maxX = Math.max(maxX, rect.x + rect.w);
+            maxY = Math.max(maxY, rect.y + rect.h);
         }
         return new Rect2(minX, minY, maxX - minX, maxY - minY);
     }

package/dist/mjs/Color4.d.ts

@@ -12,7 +12,7 @@ import Vec3 from './Vec3';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-export default class Color4 {
+export declare class Color4 {
     /** Red component. Should be in the range [0, 1]. */
     readonly r: number;
     /** Green component. ${\tt g} \in [0, 1]$ */
@@ -120,4 +120,4 @@ export default class Color4 {
     static gray: Color4;
     static white: Color4;
 }
-export { Color4 };
+export default Color4;

package/dist/mjs/Color4.mjs

@@ -12,7 +12,7 @@ import  Vec3  from './Vec3.mjs';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-class Color4 {
+export class Color4 {
     constructor(
     /** Red component. Should be in the range [0, 1]. */
     r, 
@@ -377,4 +377,3 @@ Color4.black = Color4.ofRGB(0, 0, 0);
 Color4.gray = Color4.ofRGB(0.5, 0.5, 0.5);
 Color4.white = Color4.ofRGB(1, 1, 1);
 export default Color4;
-export { Color4 };

package/dist/mjs/shapes/Path.d.ts

@@ -53,6 +53,13 @@ export declare class Path {
     getExactBBox(): Rect2;
     private cachedGeometry;
     get geometry(): GeometryArrayType;
+    /**
+     * Iterates through the start/end points of each component in this path.
+     *
+     * If a start point is equivalent to the end point of the previous segment,
+     * the point is **not** emitted twice.
+     */
+    startEndPoints(): Generator<import("../Vec3").Vec3, undefined, unknown>;
     private cachedPolylineApproximation;
     polylineApproximation(): LineSegment2[];
     static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;

package/dist/mjs/shapes/Path.mjs

@@ -45,6 +45,7 @@ export class Path {
         let startPoint = this.startPoint;
         const geometry = [];
         for (const part of this.parts) {
+            let exhaustivenessCheck;
             switch (part.kind) {
                 case PathCommandType.CubicBezierTo:
                     geometry.push(new CubicBezier(startPoint, part.controlPoint1, part.controlPoint2, part.endPoint));
@@ -62,11 +63,43 @@ export class Path {
                     geometry.push(new PointShape2D(part.point));
                     startPoint = part.point;
                     break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
             }
         }
         this.cachedGeometry = geometry;
         return this.cachedGeometry;
     }
+    /**
+     * Iterates through the start/end points of each component in this path.
+     *
+     * If a start point is equivalent to the end point of the previous segment,
+     * the point is **not** emitted twice.
+     */
+    *startEndPoints() {
+        yield this.startPoint;
+        for (const part of this.parts) {
+            let exhaustivenessCheck;
+            switch (part.kind) {
+                case PathCommandType.CubicBezierTo:
+                    yield part.endPoint;
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    yield part.endPoint;
+                    break;
+                case PathCommandType.LineTo:
+                    yield part.point;
+                    break;
+                case PathCommandType.MoveTo:
+                    yield part.point;
+                    break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
+            }
+        }
+    }
     // Approximates this path with a group of line segments.
     polylineApproximation() {
         if (this.cachedPolylineApproximation) {

package/dist/mjs/shapes/Rect2.d.ts

@@ -19,7 +19,6 @@ export declare class Rect2 extends Abstract2DShape {
     readonly h: number;
     readonly topLeft: Point2;
     readonly size: Vec2;
-    readonly bottomRight: Point2;
     readonly area: number;
     constructor(x: number, y: number, w: number, h: number);
     translatedBy(vec: Vec2): Rect2;
@@ -35,6 +34,7 @@ export declare class Rect2 extends Abstract2DShape {
     getClosestPointOnBoundaryTo(target: Point2): Vec3;
     get corners(): Point2[];
     get maxDimension(): number;
+    get bottomRight(): Vec3;
     get topRight(): Vec3;
     get bottomLeft(): Vec3;
     get width(): number;

package/dist/mjs/shapes/Rect2.mjs

@@ -20,7 +20,6 @@ export class Rect2 extends Abstract2DShape {
         // Precompute/store vector forms.
         this.topLeft = Vec2.of(this.x, this.y);
         this.size = Vec2.of(this.w, this.h);
-        this.bottomRight = this.topLeft.plus(this.size);
         this.area = this.w * this.h;
     }
     translatedBy(vec) {
@@ -36,8 +35,8 @@ export class Rect2 extends Abstract2DShape {
     }
     containsRect(other) {
         return this.x <= other.x && this.y <= other.y
-            && this.bottomRight.x >= other.bottomRight.x
-            && this.bottomRight.y >= other.bottomRight.y;
+            && this.x + this.w >= other.x + other.w
+            && this.y + this.h >= other.y + other.h;
     }
     intersects(other) {
         // Project along x/y axes.
@@ -110,6 +109,12 @@ export class Rect2 extends Abstract2DShape {
         if (margin === 0) {
             return this;
         }
+        // Prevent width/height from being negative
+        if (margin < 0) {
+            const xMargin = -Math.min(-margin, this.w / 2);
+            const yMargin = -Math.min(-margin, this.h / 2);
+            return new Rect2(this.x - xMargin, this.y - yMargin, this.w + xMargin * 2, this.h + yMargin * 2);
+        }
         return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
     }
     getClosestPointOnBoundaryTo(target) {
@@ -138,6 +143,9 @@ export class Rect2 extends Abstract2DShape {
     get maxDimension() {
         return Math.max(this.w, this.h);
     }
+    get bottomRight() {
+        return this.topLeft.plus(this.size);
+    }
     get topRight() {
         return this.bottomRight.plus(Vec2.of(0, -this.h));
     }
@@ -228,16 +236,16 @@ export class Rect2 extends Abstract2DShape {
             return Rect2.empty;
         }
         const firstRect = rects[0];
-        let minX = firstRect.topLeft.x;
-        let minY = firstRect.topLeft.y;
-        let maxX = firstRect.bottomRight.x;
-        let maxY = firstRect.bottomRight.y;
+        let minX = firstRect.x;
+        let minY = firstRect.y;
+        let maxX = firstRect.x + firstRect.w;
+        let maxY = firstRect.y + firstRect.h;
         for (let i = 1; i < rects.length; i++) {
             const rect = rects[i];
-            minX = Math.min(minX, rect.topLeft.x);
-            minY = Math.min(minY, rect.topLeft.y);
-            maxX = Math.max(maxX, rect.bottomRight.x);
-            maxY = Math.max(maxY, rect.bottomRight.y);
+            minX = Math.min(minX, rect.x);
+            minY = Math.min(minY, rect.y);
+            maxX = Math.max(maxX, rect.x + rect.w);
+            maxY = Math.max(maxY, rect.y + rect.h);
         }
         return new Rect2(minX, minY, maxX - minX, maxY - minY);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@js-draw/math",
-	"version": "1.2.2",
+	"version": "1.3.0",
 	"description": "A math library for js-draw. ",
 	"types": "./dist/mjs/lib.d.ts",
 	"main": "./dist/cjs/lib.js",
@@ -45,5 +45,5 @@
 		"svg",
 		"math"
 	],
-	"gitHead": "ced98ae289f299c44b54515571d0087aa6d32cdc"
+	"gitHead": "46b3d8f819f8e083f6e3e1d01e027e4311355456"
 }

package/src/Color4.ts

@@ -13,7 +13,7 @@ import Vec3 from './Vec3';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-export default class Color4 {
+export class Color4 {
 	private constructor(
 		/** Red component. Should be in the range [0, 1]. */
 		public readonly r: number,
@@ -437,4 +437,4 @@ export default class Color4 {
 	public static white = Color4.ofRGB(1, 1, 1);
 }
 
-export { Color4 };
+export default Color4;

package/src/shapes/Path.ts

@@ -97,6 +97,8 @@ export class Path {
 		const geometry: GeometryArrayType = [];
 
 		for (const part of this.parts) {
+			let exhaustivenessCheck: never;
+
 			switch (part.kind) {
 			case PathCommandType.CubicBezierTo:
 				geometry.push(
@@ -124,6 +126,9 @@ export class Path {
 				geometry.push(new PointShape2D(part.point));
 				startPoint = part.point;
 				break;
+			default:
+				exhaustivenessCheck = part;
+				return exhaustivenessCheck;
 			}
 		}
 
@@ -131,6 +136,38 @@ export class Path {
 		return this.cachedGeometry;
 	}
 
+	/**
+	 * Iterates through the start/end points of each component in this path.
+	 *
+	 * If a start point is equivalent to the end point of the previous segment,
+	 * the point is **not** emitted twice.
+	 */
+	public *startEndPoints() {
+		yield this.startPoint;
+
+		for (const part of this.parts) {
+			let exhaustivenessCheck: never;
+
+			switch (part.kind) {
+			case PathCommandType.CubicBezierTo:
+				yield part.endPoint;
+				break;
+			case PathCommandType.QuadraticBezierTo:
+				yield part.endPoint;
+				break;
+			case PathCommandType.LineTo:
+				yield part.point;
+				break;
+			case PathCommandType.MoveTo:
+				yield part.point;
+				break;
+			default:
+				exhaustivenessCheck = part;
+				return exhaustivenessCheck;
+			}
+		}
+	}
+
 	private cachedPolylineApproximation: LineSegment2[]|null = null;
 
 	// Approximates this path with a group of line segments.

package/src/shapes/Rect2.test.ts

@@ -111,6 +111,27 @@ describe('Rect2', () => {
 		expect(new Rect2(-100, -1, 200, 2).intersects(new Rect2(-5, 50, 10, 30))).toBe(false);
 	});
 
+	it('should correctly compute the intersection of one rectangle and several others', () => {
+		const mainRect = new Rect2(334,156,333,179);
+		const shouldIntersect = [
+			new Rect2(400.8, 134.8, 8.4, 161.4),
+			new Rect2(324.8,93,164.4,75.2),
+			new Rect2(435.8,146.8,213.2,192.6),
+			new Rect2(550.8,211.8,3.4,3.4),
+			new Rect2(478.8,93.8,212.4,95.4),
+		];
+		const shouldNotIntersect = [
+			new Rect2(200, 200, 1, 1),
+		];
+
+		for (const rect of shouldIntersect) {
+			expect(mainRect.intersects(rect)).toBe(true);
+		}
+		for (const rect of shouldNotIntersect) {
+			expect(mainRect.intersects(rect)).toBe(false);
+		}
+	});
+
 	it('intersecting rectangles should have their intersections correctly computed', () => {
 		expect(new Rect2(-1, -1, 2, 2).intersection(Rect2.empty)).objEq(Rect2.empty);
 		expect(new Rect2(-1, -1, 2, 2).intersection(new Rect2(0, 0, 3, 3))).objEq(
@@ -130,6 +151,19 @@ describe('Rect2', () => {
 		expect(transformedBBox.containsRect(rect)).toBe(true);
 	});
 
+	it('.grownBy should expand a rectangle by the given margin', () => {
+		expect(Rect2.empty.grownBy(0)).toBe(Rect2.empty);
+
+		// Should add padding to all sides.
+		expect(new Rect2(1, 2, 3, 4).grownBy(1)).objEq(new Rect2(0, 1, 5, 6));
+
+		// Shrinking should not result in negative widths/heights and
+		// should adjust x/y appropriately
+		expect(new Rect2(1, 2, 1, 2).grownBy(-1)).objEq(new Rect2(1.5, 3, 0, 0));
+		expect(new Rect2(1, 2, 4, 4).grownBy(-1)).objEq(new Rect2(2, 3, 2, 2));
+		expect(new Rect2(1, 2, 2, 8).grownBy(-2)).objEq(new Rect2(2, 4, 0, 4));
+	});
+
 	describe('should correctly expand to include a given point', () => {
 		it('Growing an empty rectange to include (1, 0)', () => {
 			const originalRect = Rect2.empty;

package/src/shapes/Rect2.ts

@@ -21,7 +21,6 @@ export class Rect2 extends Abstract2DShape {
 	// topLeft assumes up is -y
 	public readonly topLeft: Point2;
 	public readonly size: Vec2;
-	public readonly bottomRight: Point2;
 	public readonly area: number;
 
 	public constructor(
@@ -45,7 +44,6 @@ export class Rect2 extends Abstract2DShape {
 		// Precompute/store vector forms.
 		this.topLeft = Vec2.of(this.x, this.y);
 		this.size = Vec2.of(this.w, this.h);
-		this.bottomRight = this.topLeft.plus(this.size);
 		this.area = this.w * this.h;
 	}
 
@@ -65,8 +63,8 @@ export class Rect2 extends Abstract2DShape {
 
 	public containsRect(other: Rect2): boolean {
 		return this.x <= other.x && this.y <= other.y
-				&& this.bottomRight.x >= other.bottomRight.x
-				&& this.bottomRight.y >= other.bottomRight.y;
+				&& this.x + this.w >= other.x + other.w
+				&& this.y + this.h >= other.y + other.h;
 	}
 
 	public intersects(other: Rect2): boolean {
@@ -159,6 +157,17 @@ export class Rect2 extends Abstract2DShape {
 			return this;
 		}
 
+		// Prevent width/height from being negative
+		if (margin < 0) {
+			const xMargin = -Math.min(-margin, this.w / 2);
+			const yMargin = -Math.min(-margin, this.h / 2);
+
+			return new Rect2(
+				this.x - xMargin, this.y - yMargin,
+				this.w + xMargin * 2, this.h + yMargin * 2,
+			);
+		}
+
 		return new Rect2(
 			this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2
 		);
@@ -194,6 +203,10 @@ export class Rect2 extends Abstract2DShape {
 		return Math.max(this.w, this.h);
 	}
 
+	public get bottomRight() {
+		return this.topLeft.plus(this.size);
+	}
+
 	public get topRight() {
 		return this.bottomRight.plus(Vec2.of(0, -this.h));
 	}
@@ -315,17 +328,17 @@ export class Rect2 extends Abstract2DShape {
 		}
 
 		const firstRect = rects[0];
-		let minX: number = firstRect.topLeft.x;
-		let minY: number = firstRect.topLeft.y;
-		let maxX: number = firstRect.bottomRight.x;
-		let maxY: number = firstRect.bottomRight.y;
+		let minX: number = firstRect.x;
+		let minY: number = firstRect.y;
+		let maxX: number = firstRect.x + firstRect.w;
+		let maxY: number = firstRect.y + firstRect.h;
 
 		for (let i = 1; i < rects.length; i++) {
 			const rect = rects[i];
-			minX = Math.min(minX, rect.topLeft.x);
-			minY = Math.min(minY, rect.topLeft.y);
-			maxX = Math.max(maxX, rect.bottomRight.x);
-			maxY = Math.max(maxY, rect.bottomRight.y);
+			minX = Math.min(minX, rect.x);
+			minY = Math.min(minY, rect.y);
+			maxX = Math.max(maxX, rect.x + rect.w);
+			maxY = Math.max(maxY, rect.y + rect.h);
 		}
 
 		return new Rect2(