@js-draw/math 1.2.2 → 1.3.1

package/src/Mat33.ts

@@ -335,9 +335,37 @@ export class Mat33 {
 		return Math.hypot(this.a1, this.a2);
 	}
 
+	/** Returns the `idx`-th column (`idx` is 0-indexed). */
+	public getColumn(idx: number) {
+		return Vec3.of(
+			this.rows[0].at(idx),
+			this.rows[1].at(idx),
+			this.rows[2].at(idx),
+		);
+	}
+
+	/** Returns the magnitude of the entry with the largest entry */
+	public maximumEntryMagnitude() {
+		let greatestSoFar = Math.abs(this.a1);
+		for (const entry of this.toArray()) {
+			greatestSoFar = Math.max(greatestSoFar, Math.abs(entry));
+		}
+
+		return greatestSoFar;
+	}
+
 	/**
 	 * Constructs a 3x3 translation matrix (for translating `Vec2`s) using
 	 * **transformVec2**.
+	 *
+	 * Creates a matrix in the form
+	 * $$
+	 * 	\begin{pmatrix}
+	 * 		1 & 0 & {\tt amount.x}\\
+	 * 		0 & 1 & {\tt amount.y}\\
+	 * 		0 & 0 & 1
+	 * 	\end{pmatrix}
+	 * $$
 	 */
 	public static translation(amount: Vec2): Mat33 {
 		// When transforming Vec2s by a 3x3 matrix, we give the input
@@ -392,7 +420,11 @@ export class Mat33 {
 		return result.rightMul(Mat33.translation(center.times(-1)));
 	}
 
-	/** @see {@link fromCSSMatrix} */
+	/**
+	 * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+	 *
+	 * @see {@link fromCSSMatrix} and {@link toSafeCSSTransformList}
+	 */
 	public toCSSMatrix(): string {
 		return `matrix(${this.a1},${this.b1},${this.a2},${this.b2},${this.a3},${this.b3})`;
 	}
@@ -412,39 +444,118 @@ export class Mat33 {
 			return Mat33.identity;
 		}
 
-		const numberExp = '([-]?\\d*(?:\\.\\d*)?(?:[eE][-]?\\d+)?)';
-		const numberSepExp = '[, \\t\\n]';
-		const regExpSource = `^\\s*matrix\\s*\\(${
-			[
-				// According to MDN, matrix(a,b,c,d,e,f) has form:
-				// 		⎡ a c e ⎤
-				// 		⎢ b d f ⎥
-				// 		⎣ 0 0 1 ⎦
-				numberExp, numberExp, numberExp, // a, c, e
-				numberExp, numberExp, numberExp, // b, d, f
-			].join(`${numberSepExp}+`)
-		}${numberSepExp}*\\)\\s*$`;
-		const matrixExp = new RegExp(regExpSource, 'i');
-		const match = matrixExp.exec(cssString);
-
-		if (!match) {
-			throw new Error(`Unsupported transformation: ${cssString}`);
+		const parseArguments = (argumentString: string) => {
+			return argumentString.split(/[, \t\n]+/g).map(argString => {
+				let isPercentage = false;
+				if (argString.endsWith('%')) {
+					isPercentage = true;
+					argString = argString.substring(0, argString.length - 1);
+				}
+
+				// Remove trailing px units.
+				argString = argString.replace(/px$/ig, '');
+
+				const numberExp = /^[-]?\d*(?:\.\d*)?(?:[eE][-+]?\d+)?$/i;
+
+				if (!numberExp.exec(argString)) {
+					throw new Error(
+						`All arguments to transform functions must be numeric (state: ${
+							JSON.stringify({
+								currentArgument: argString,
+								allArguments: argumentString,
+							})
+						})`
+					);
+				}
+
+				let argNumber = parseFloat(argString);
+
+				if (isPercentage) {
+					argNumber /= 100;
+				}
+
+				return argNumber;
+			});
+		};
+
+
+		const keywordToAction = {
+			matrix: (matrixData: number[]) => {
+				if (matrixData.length !== 6) {
+					throw new Error(`Invalid matrix argument: ${matrixData}. Must have length 6`);
+				}
+
+				const a = matrixData[0];
+				const b = matrixData[1];
+				const c = matrixData[2];
+				const d = matrixData[3];
+				const e = matrixData[4];
+				const f = matrixData[5];
+
+				const transform = new Mat33(
+					a, c, e,
+					b, d, f,
+					0, 0, 1
+				);
+				return transform;
+			},
+
+			scale: (scaleArgs: number[]) => {
+				let scaleX, scaleY;
+				if (scaleArgs.length === 1) {
+					scaleX = scaleArgs[0];
+					scaleY = scaleArgs[0];
+				} else if (scaleArgs.length === 2) {
+					scaleX = scaleArgs[0];
+					scaleY = scaleArgs[1];
+				} else {
+					throw new Error(`The scale() function only supports two arguments. Given: ${scaleArgs}`);
+				}
+
+				return Mat33.scaling2D(Vec2.of(scaleX, scaleY));
+			},
+
+			translate: (translateArgs: number[]) => {
+				let translateX = 0;
+				let translateY = 0;
+
+				if (translateArgs.length === 1) {
+					// If no y translation is given, assume 0.
+					translateX = translateArgs[0];
+				} else if (translateArgs.length === 2) {
+					translateX = translateArgs[0];
+					translateY = translateArgs[1];
+				} else {
+					throw new Error(`The translate() function requires either 1 or 2 arguments. Given ${translateArgs}`);
+				}
+
+				return Mat33.translation(Vec2.of(translateX, translateY));
+			},
+		};
+
+		// A command (\w+)
+		// followed by a set of arguments ([ \t\n0-9eE.,\-%]+)
+		const partRegex = /\s*(\w+)\s*\(([^)]*)\)/ig;
+		let match;
+		let matrix: Mat33|null = null;
+
+		while ((match = partRegex.exec(cssString)) !== null) {
+			const action = match[1].toLowerCase();
+			if (!(action in keywordToAction)) {
+				throw new Error(`Unsupported CSS transform action: ${action}`);
+			}
+
+			const args = parseArguments(match[2]);
+			const currentMatrix = keywordToAction[action as keyof typeof keywordToAction](args);
+
+			if (!matrix) {
+				matrix = currentMatrix;
+			} else {
+				matrix = matrix.rightMul(currentMatrix);
+			}
 		}
 
-		const matrixData = match.slice(1).map(entry => parseFloat(entry));
-		const a = matrixData[0];
-		const b = matrixData[1];
-		const c = matrixData[2];
-		const d = matrixData[3];
-		const e = matrixData[4];
-		const f = matrixData[5];
-
-		const transform = new Mat33(
-			a, c, e,
-			b, d, f,
-			0, 0, 1
-		);
-		return transform;
+		return matrix ?? Mat33.identity;
 	}
 }
 export default Mat33;

package/src/Vec3.ts

@@ -63,6 +63,16 @@ export class Vec3 {
 		return this.dot(this);
 	}
 
+	/**
+	 * Returns the entry of this with the greatest magnitude.
+	 *
+	 * In other words, returns $\max \{ |x| : x \in {\bf v} \}$, where ${\bf v}$ is the set of
+	 * all entries of this vector.
+	 */
+	public maximumEntryMagnitude(): number {
+		return Math.max(Math.abs(this.x), Math.max(Math.abs(this.y), Math.abs(this.z)));
+	}
+
 	/**
 	 * Return this' angle in the XY plane (treats this as a Vec2).
 	 *

package/src/rounding.ts

@@ -165,3 +165,4 @@ export const toStringOfSamePrecision = (num: number, ...references: string[]): s
 	const negativeSign = textMatch[1];
 	return cleanUpNumber(`${negativeSign}${preDecimal}.${postDecimal}`);
 };
+

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(