@js-draw/math 1.17.0 → 1.18.0

package/src/shapes/Path.ts

@@ -8,6 +8,8 @@ import PointShape2D from './PointShape2D';
 import toRoundedString from '../rounding/toRoundedString';
 import toStringOfSamePrecision from '../rounding/toStringOfSamePrecision';
 import Parameterized2DShape from './Parameterized2DShape';
+import BezierJSWrapper from './BezierJSWrapper';
+import convexHull2Of from '../utils/convexHull2Of';
 
 export enum PathCommandType {
 	LineTo,
@@ -47,13 +49,22 @@ export interface IntersectionResult {
 	// @internal
 	curveIndex: number;
 
-	/** Parameter value for the closest point **on** the path to the intersection. @internal @deprecated */
-	parameterValue?: number;
+	/** Parameter value for the closest point **on** the path to the intersection. @internal */
+	parameterValue: number;
 
 	/** Point at which the intersection occured. */
 	point: Point2;
 }
 
+/** Options for {@link Path.splitNear} and {@link Path.splitAt} */
+export interface PathSplitOptions {
+	/**
+	 * Allows mapping points on newly added segments. This is useful, for example,
+	 * to round points to prevent long decimals when later saving.
+	 */
+	mapNewPoint?: (point: Point2)=>Point2;
+}
+
 /**
  * Allows indexing a particular part of a path.
  *
@@ -64,8 +75,64 @@ export interface CurveIndexRecord {
 	parameterValue: number;
 }
 
+/** Returns a positive number if `a` comes after `b`, 0 if equal, and negative otherwise. */
+export const compareCurveIndices = (a: CurveIndexRecord, b: CurveIndexRecord) => {
+	const indexCompare = a.curveIndex - b.curveIndex;
+	if (indexCompare === 0) {
+		return a.parameterValue - b.parameterValue;
+	} else {
+		return indexCompare;
+	}
+};
+
+/**
+ * Returns a version of `index` with its parameter value incremented by `stepBy`
+ * (which can be either positive or negative).
+ */
+export const stepCurveIndexBy = (index: CurveIndexRecord, stepBy: number): CurveIndexRecord => {
+	if (index.parameterValue + stepBy > 1) {
+		return { curveIndex: index.curveIndex + 1, parameterValue: index.parameterValue + stepBy - 1 };
+	}
+	if (index.parameterValue + stepBy < 0) {
+		if (index.curveIndex === 0) {
+			return { curveIndex: 0, parameterValue: 0 };
+		}
+		return { curveIndex: index.curveIndex - 1, parameterValue: index.parameterValue + stepBy + 1 };
+	}
+
+	return { curveIndex: index.curveIndex, parameterValue: index.parameterValue + stepBy };
+};
+
 /**
  * Represents a union of lines and curves.
+ *
+ * To create a path from a string, see {@link fromString}.
+ *
+ * @example
+ * ```ts,runnable,console
+ * import {Path, Mat33, Vec2, LineSegment2} from '@js-draw/math';
+ *
+ * // Creates a path from an SVG path string.
+ * // In this case,
+ * // 1. Move to (0,0)
+ * // 2. Line to (100,0)
+ * const path = Path.fromString('M0,0 L100,0');
+ *
+ * // Logs the distance from (10,0) to the curve 1 unit
+ * // away from path. This curve forms a stroke with the path at
+ * // its center.
+ * const strokeRadius = 1;
+ * console.log(path.signedDistance(Vec2.of(10,0), strokeRadius));
+ *
+ * // Log a version of the path that's scaled by a factor of 4.
+ * console.log(path.transformedBy(Mat33.scaling2D(4)).toString());
+ *
+ * // Log all intersections of a stroked version of the path with
+ * // a vertical line segment.
+ * // (Try removing the `strokeRadius` parameter).
+ * const segment = new LineSegment2(Vec2.of(5, -100), Vec2.of(5, 100));
+ * console.log(path.intersection(segment, strokeRadius).map(i => i.point));
+ * ```
  */
 export class Path {
 	/**
@@ -100,6 +167,12 @@ export class Path {
 		}
 	}
 
+	/**
+	 * Computes and returns the full bounding box for this path.
+	 *
+	 * If a slight over-estimate of a path's bounding box is sufficient, use
+	 * {@link bbox} instead.
+	 */
 	public getExactBBox(): Rect2 {
 		const bboxes: Rect2[] = [];
 		for (const part of this.geometry) {
@@ -249,7 +322,20 @@ export class Path {
 		return Rect2.bboxOf(points);
 	}
 
-	/** **Note**: `strokeRadius = strokeWidth / 2` */
+	/**
+	 * Returns the signed distance between `point` and a curve `strokeRadius` units
+	 * away from this path.
+	 *
+	 * This returns the **signed distance**, which means that points inside this shape
+	 * have their distance negated. For example,
+	 * ```ts,runnable,console
+	 * import {Path, Vec2} from '@js-draw/math';
+	 * console.log(Path.fromString('m0,0 L100,0').signedDistance(Vec2.zero, 1));
+	 * ```
+	 * would print `-1` because (0,0) is on `m0,0 L100,0` and thus one unit away from its boundary.
+	 *
+	 * **Note**: `strokeRadius = strokeWidth / 2`
+	 */
 	public signedDistance(point: Point2, strokeRadius: number) {
 		let minDist = Infinity;
 
@@ -367,7 +453,7 @@ export class Path {
 
 
 		// Raymarch:
-		const maxRaymarchSteps = 7;
+		const maxRaymarchSteps = 8;
 
 		// Start raymarching from each of these points. This allows detection of multiple
 		// intersections.
@@ -458,7 +544,7 @@ export class Path {
 			if (lastPart && isOnLineSegment && Math.abs(lastDist) < stoppingThreshold) {
 				result.push({
 					point: currentPoint,
-					parameterValue: NaN,// lastPart.nearestPointTo(currentPoint).parameterValue,
+					parameterValue: lastPart.nearestPointTo(currentPoint).parameterValue,
 					curve: lastPart,
 					curveIndex: this.geometry.indexOf(lastPart),
 				});
@@ -507,6 +593,10 @@ export class Path {
 			return [];
 		}
 
+		if (this.parts.length === 0) {
+			return new Path(this.startPoint, [{ kind: PathCommandType.MoveTo, point: this.startPoint }]).intersection(line, strokeRadius);
+		}
+
 		let index = 0;
 		for (const part of this.geometry) {
 			const intersections = part.argIntersectsLineSegment(line);
@@ -538,9 +628,6 @@ export class Path {
 
 	/**
 	 * @returns the nearest point on this path to the given `point`.
-	 *
-	 * @internal
-	 * @beta
 	 */
 	public nearestPointTo(point: Point2): IntersectionResult {
 		// Find the closest point on this
@@ -570,6 +657,9 @@ export class Path {
 	}
 
 	public at(index: CurveIndexRecord) {
+		if (index.curveIndex === 0 && index.parameterValue === 0) {
+			return this.startPoint;
+		}
 		return this.geometry[index.curveIndex].at(index.parameterValue);
 	}
 
@@ -577,6 +667,246 @@ export class Path {
 		return this.geometry[index.curveIndex].tangentAt(index.parameterValue);
 	}
 
+	/** Splits this path in two near the given `point`. */
+	public splitNear(point: Point2, options?: PathSplitOptions) {
+		const nearest = this.nearestPointTo(point);
+		return this.splitAt(nearest, options);
+	}
+
+	/**
+	 * Returns a copy of this path with `deleteFrom` until `deleteUntil` replaced with `insert`.
+	 *
+	 * This method is analogous to {@link Array.toSpliced}.
+	 */
+	public spliced(deleteFrom: CurveIndexRecord, deleteTo: CurveIndexRecord, insert: Path|undefined, options?: PathSplitOptions): Path {
+		const isBeforeOrEqual = (a: CurveIndexRecord, b: CurveIndexRecord) => {
+			return a.curveIndex < b.curveIndex || (a.curveIndex === b.curveIndex && a.parameterValue <= b.parameterValue);
+		};
+
+		if (isBeforeOrEqual(deleteFrom, deleteTo)) {
+			//          deleteFrom        deleteTo
+			//      <---------|             |-------------->
+			//      x                                      x
+			//  startPoint                             endPoint
+			const firstSplit = this.splitAt(deleteFrom, options);
+			const secondSplit = this.splitAt(deleteTo, options);
+			const before = firstSplit[0];
+			const after = secondSplit[secondSplit.length - 1];
+			return insert ? before.union(insert).union(after) : before.union(after);
+		} else {
+			// In this case, we need to handle wrapping at the start/end.
+			//          deleteTo        deleteFrom
+			//      <---------|    keep     |-------------->
+			//      x                                      x
+			//  startPoint                             endPoint
+			const splitAtFrom = this.splitAt([deleteFrom], options);
+			const beforeFrom = splitAtFrom[0];
+
+			// We need splitNear, rather than splitAt, because beforeFrom does not have
+			// the same indexing as this.
+			const splitAtTo = beforeFrom.splitNear(this.at(deleteTo), options);
+
+			const betweenBoth = splitAtTo[splitAtTo.length - 1];
+			return insert ? betweenBoth.union(insert) : betweenBoth;
+		}
+	}
+
+	public splitAt(at: CurveIndexRecord, options?: PathSplitOptions): [Path]|[Path, Path];
+	public splitAt(at: CurveIndexRecord[], options?: PathSplitOptions): Path[];
+
+	// @internal
+	public splitAt(splitAt: CurveIndexRecord[]|CurveIndexRecord, options?: PathSplitOptions): Path[] {
+		if (!Array.isArray(splitAt)) {
+			splitAt = [splitAt];
+		}
+
+		splitAt = [...splitAt];
+		splitAt.sort(compareCurveIndices);
+
+		//
+		// Bounds checking & reversal.
+		//
+
+		while (
+			splitAt.length > 0
+			&& splitAt[splitAt.length - 1].curveIndex >= this.parts.length - 1
+			&& splitAt[splitAt.length - 1].parameterValue >= 1
+		) {
+			splitAt.pop();
+		}
+
+		splitAt.reverse(); // .reverse() <-- We're `.pop`ing from the end
+
+		while (
+			splitAt.length > 0
+			&& splitAt[splitAt.length - 1].curveIndex <= 0
+			&& splitAt[splitAt.length - 1].parameterValue <= 0
+		) {
+			splitAt.pop();
+		}
+
+		if (splitAt.length === 0 || this.parts.length === 0) {
+			return [this];
+		}
+
+		const expectedSplitCount = splitAt.length + 1;
+		const mapNewPoint = options?.mapNewPoint ?? ((p: Point2)=>p);
+
+		const result: Path[] = [];
+		let currentStartPoint = this.startPoint;
+		let currentPath: PathCommand[] = [];
+
+		//
+		// Splitting
+		//
+
+		let { curveIndex, parameterValue } = splitAt.pop()!;
+
+		for (let i = 0; i < this.parts.length; i ++) {
+			if (i !== curveIndex) {
+				currentPath.push(this.parts[i]);
+			} else {
+				let part = this.parts[i];
+				let geom = this.geometry[i];
+				while (i === curveIndex) {
+					let newPathStart: Point2;
+					const newPath: PathCommand[] = [];
+
+					switch (part.kind) {
+					case PathCommandType.MoveTo:
+						currentPath.push({
+							kind: part.kind,
+							point: part.point,
+						});
+						newPathStart = part.point;
+						break;
+					case PathCommandType.LineTo:
+						{
+							const split = (geom as LineSegment2).splitAt(parameterValue);
+							currentPath.push({
+								kind: part.kind,
+								point: mapNewPoint(split[0].p2),
+							});
+							newPathStart = split[0].p2;
+							if (split.length > 1) {
+								console.assert(split.length === 2);
+								newPath.push({
+									kind: part.kind,
+
+									// Don't map: For lines, the end point of the split is
+									// the same as the end point of the original:
+									point: split[1]!.p2,
+								});
+								geom = split[1]!;
+							}
+						}
+						break;
+					case PathCommandType.QuadraticBezierTo:
+					case PathCommandType.CubicBezierTo:
+						{
+							const split = (geom as BezierJSWrapper).splitAt(parameterValue);
+							let isFirstPart = split.length === 2;
+							for (const segment of split) {
+								geom = segment;
+								const targetArray = isFirstPart ? currentPath : newPath;
+								const controlPoints = segment.getPoints();
+								if (part.kind === PathCommandType.CubicBezierTo) {
+									targetArray.push({
+										kind: part.kind,
+										controlPoint1: mapNewPoint(controlPoints[1]),
+										controlPoint2: mapNewPoint(controlPoints[2]),
+										endPoint: mapNewPoint(controlPoints[3]),
+									});
+								} else {
+									targetArray.push({
+										kind: part.kind,
+										controlPoint: mapNewPoint(controlPoints[1]),
+										endPoint: mapNewPoint(controlPoints[2]),
+									});
+								}
+
+								// We want the start of the new path to match the start of the
+								// FIRST Bézier in the NEW path.
+								if (!isFirstPart) {
+									newPathStart = controlPoints[0];
+								}
+								isFirstPart = false;
+							}
+						}
+						break;
+					default: {
+						const exhaustivenessCheck: never = part;
+						return exhaustivenessCheck;
+					}
+					}
+
+					result.push(new Path(currentStartPoint, [...currentPath]));
+					currentStartPoint = mapNewPoint(newPathStart!);
+					console.assert(!!currentStartPoint, 'should have a start point');
+					currentPath = newPath;
+					part = newPath[newPath.length - 1] ?? part;
+
+					const nextSplit = splitAt.pop();
+					if (!nextSplit) {
+						break;
+					} else {
+						curveIndex = nextSplit.curveIndex;
+						if (i === curveIndex) {
+							const originalPoint = this.at(nextSplit);
+							parameterValue = geom.nearestPointTo(originalPoint).parameterValue;
+							currentPath = [];
+						} else {
+							parameterValue = nextSplit.parameterValue;
+						}
+					}
+				}
+			}
+		}
+
+		result.push(new Path(currentStartPoint, currentPath));
+
+		console.assert(
+			result.length === expectedSplitCount,
+			`should split into splitAt.length + 1 splits (was ${result.length}, expected ${expectedSplitCount})`
+		);
+		return result;
+	}
+
+	/**
+	 * Replaces all `MoveTo` commands with `LineTo` commands and connects the end point of this
+	 * path to the start point.
+	 */
+	public asClosed() {
+		const newParts: PathCommand[] = [];
+		let hasChanges = false;
+		for (const part of this.parts) {
+			if (part.kind === PathCommandType.MoveTo) {
+				newParts.push({
+					kind: PathCommandType.LineTo,
+					point: part.point,
+				});
+				hasChanges = true;
+			} else {
+				newParts.push(part);
+			}
+		}
+		if (!this.getEndPoint().eq(this.startPoint)) {
+			newParts.push({
+				kind: PathCommandType.LineTo,
+				point: this.startPoint,
+			});
+			hasChanges = true;
+		}
+
+		if (!hasChanges) {
+			return this;
+		}
+
+		const result = new Path(this.startPoint, newParts);
+		console.assert(result.getEndPoint().eq(result.startPoint));
+		return result;
+	}
+
 	private static mapPathCommand(part: PathCommand, mapping: (point: Point2)=> Point2): PathCommand {
 		switch (part.kind) {
 		case PathCommandType.MoveTo:
@@ -626,9 +956,25 @@ export class Path {
 		return this.mapPoints(point => affineTransfm.transformVec2(point));
 	}
 
+	/**
+	 * @internal
+	 */
+	public closedContainsPoint(point: Point2) {
+		const bbox = this.getExactBBox();
+		if (!bbox.containsPoint(point)) {
+			return false;
+		}
+
+		const pointOutside = point.plus(Vec2.of(bbox.width, 0));
+		const asClosed = this.asClosed();
+
+		const lineToOutside = new LineSegment2(point, pointOutside);
+		return asClosed.intersection(lineToOutside).length % 2 === 1;
+	}
+
 	// Creates a new path by joining [other] to the end of this path
 	public union(
-		other: Path|null,
+		other: Path|PathCommand[]|null,
 
 		// allowReverse: true iff reversing other or this is permitted if it means
 		//               no moveTo command is necessary when unioning the paths.
@@ -637,6 +983,9 @@ export class Path {
 		if (!other) {
 			return this;
 		}
+		if (Array.isArray(other)) {
+			return new Path(this.startPoint, [...this.parts, ...other]);
+		}
 
 		const thisEnd = this.getEndPoint();
 
@@ -711,7 +1060,8 @@ export class Path {
 		return new Path(newStart, newParts);
 	}
 
-	private getEndPoint() {
+	/** Computes and returns the end point of this path */
+	public getEndPoint() {
 		if (this.parts.length === 0) {
 			return this.startPoint;
 		}
@@ -766,10 +1116,12 @@ export class Path {
 		return false;
 	}
 
-	// Treats this as a closed path and returns true if part of `rect` is *roughly* within
-	// this path's interior.
-	//
-	// Note: Assumes that this is a closed, non-self-intersecting path.
+	/**
+	 * Treats this as a closed path and returns true if part of `rect` is *roughly* within
+	 * this path's interior.
+	 *
+	 * **Note**: Assumes that this is a closed, non-self-intersecting path.
+	 */
 	public closedRoughlyIntersects(rect: Rect2): boolean {
 		if (rect.containsRect(this.bbox)) {
 			return true;
@@ -1035,10 +1387,8 @@ export class Path {
 	/**
 	 * Create a `Path` from a subset of the SVG path specification.
 	 *
-	 * ## To-do
-	 * - TODO: Support a larger subset of SVG paths
-	 *   - Elliptical arcs are currently unsupported.
-	 * - TODO: Support `s`,`t` commands shorthands.
+	 * Currently, this does not support elliptical arcs or `s` and `t` command
+	 * shorthands. See https://github.com/personalizedrefrigerator/js-draw/pull/19.
 	 *
 	 * @example
 	 * ```ts,runnable,console
@@ -1049,6 +1399,8 @@ export class Path {
 	 * ```
 	 */
 	public static fromString(pathString: string): Path {
+		// TODO: Support elliptical arcs, and the `s`, `t` command shorthands.
+		//
 		// See the MDN reference:
 		// https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d
 		// and
@@ -1236,6 +1588,26 @@ export class Path {
 		return result;
 	}
 
+	public static fromConvexHullOf(points: Point2[]) {
+		if (points.length === 0) {
+			return Path.empty;
+		}
+
+		const hull = convexHull2Of(points);
+
+		const commands = hull.slice(1).map((p): LinePathCommand => ({
+			kind: PathCommandType.LineTo,
+			point: p,
+		}));
+		// Close -- connect back to the start
+		commands.push({
+			kind: PathCommandType.LineTo,
+			point: hull[0],
+		});
+
+		return new Path(hull[0], commands);
+	}
+
 	// @internal TODO: At present, this isn't really an empty path.
 	public static empty: Path = new Path(Vec2.zero, []);
 }

package/src/shapes/QuadraticBezier.test.ts

@@ -37,6 +37,9 @@ describe('QuadraticBezier', () => {
 		// Should not return an out-of-range parameter
 		[ new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.unitY), Vec2.of(0, -1000), 0 ],
 		[ new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.unitY), Vec2.of(0, 1000), 1 ],
+
+		// Edge case -- just a point
+		[ new QuadraticBezier(Vec2.zero, Vec2.zero, Vec2.zero), Vec2.of(0, 1000), 0 ],
 	])('nearestPointTo should return the nearest point and parameter value on %s to %s', (bezier, point, expectedParameter) => {
 		const nearest = bezier.nearestPointTo(point);
 		expect(nearest.parameterValue).toBeCloseTo(expectedParameter, 0.0001);
@@ -64,4 +67,22 @@ describe('QuadraticBezier', () => {
 			}
 		}
 	});
+
+	test.each([
+		new QuadraticBezier(Vec2.zero, Vec2.unitY, Vec2.unitY.times(2)),
+		new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY),
+		new QuadraticBezier(Vec2.zero, Vec2.unitY, Vec2.unitX),
+	])('.derivativeAt should return a derivative vector with the correct direction (curve: %s)', (curve) => {
+		for (let t = 0; t < 1; t += 0.1) {
+			const derivative = curve.derivativeAt(t);
+			const derivativeApprox = curve.at(t + 0.001).minus(curve.at(t - 0.001));
+			expect(derivativeApprox.normalized()).objEq(derivative.normalized(), 0.01);
+		}
+	});
+
+	test('should support Bezier-Bezier intersections', () => {
+		const b1 = new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY);
+		const b2 = new QuadraticBezier(Vec2.of(-1, 0.5), Vec2.of(0, 0.6), Vec2.of(1, 0.4));
+		expect(b1.intersectsBezier(b2)).toHaveLength(1);
+	});
 });

package/src/shapes/QuadraticBezier.ts

@@ -4,10 +4,9 @@ import BezierJSWrapper from './BezierJSWrapper';
 import Rect2 from './Rect2';
 
 /**
- * A wrapper around `bezier-js`'s quadratic Bézier.
+ * Represents a 2D Bézier curve.
  *
- * This wrappper lazy-loads `bezier-js`'s Bézier and can perform some operations
- * without loading it at all (e.g. `normal`, `at`, and `approximateDistance`).
+ * **Note**: Many Bézier operations use `bezier-js`'s.
  */
 export class QuadraticBezier extends BezierJSWrapper {
 	public constructor(

package/src/shapes/Rect2.ts

@@ -4,7 +4,7 @@ import { Point2, Vec2 } from '../Vec2';
 import Abstract2DShape from './Abstract2DShape';
 import Vec3 from '../Vec3';
 
-/** An object that can be converted to a Rect2. */
+/** An object that can be converted to a {@link Rect2}. */
 export interface RectTemplate {
 	x: number;
 	y: number;
@@ -14,7 +14,11 @@ export interface RectTemplate {
 	height?: number;
 }
 
-// invariant: w ≥ 0, h ≥ 0, immutable
+/**
+ * Represents a rectangle in 2D space, parallel to the XY axes.
+ *
+ * `invariant: w ≥ 0, h ≥ 0, immutable`
+ */
 export class Rect2 extends Abstract2DShape {
 	// Derived state:
 

package/src/utils/convexHull2Of.test.ts

@@ -0,0 +1,43 @@
+import { Vec2 } from '../Vec2';
+import { Rect2 } from '../shapes/Rect2';
+import convexHull2Of from './convexHull2Of';
+
+describe('convexHull2Of', () => {
+	it.each([
+		[ [ Vec2.of(1, 1) ] , [ Vec2.of(1, 1) ] ],
+
+		// Line
+		[ [ Vec2.of(1, 1), Vec2.of(2, 2) ] , [ Vec2.of(1, 1), Vec2.of(2, 2) ] ],
+
+		// Just a triangle
+		[ [ Vec2.of(1, 1), Vec2.of(4, 2), Vec2.of(3, 3) ] , [ Vec2.of(1, 1), Vec2.of(4, 2), Vec2.of(3, 3) ]],
+
+		// Triangle with an extra point
+		[ [ Vec2.of(1, 1), Vec2.of(2, 20), Vec2.of(3, 5), Vec2.of(4, 3) ] , [ Vec2.of(1, 1), Vec2.of(4, 3), Vec2.of(2, 20) ]],
+
+		// Points within a triangle
+		[
+			[ Vec2.of(28, 5), Vec2.of(4, 5), Vec2.of(-100, -100), Vec2.of(7, 120), Vec2.of(1, 8), Vec2.of(100, -100), Vec2.of(2, 4), Vec2.of(3, 4), Vec2.of(4, 5) ],
+			[ Vec2.of(-100, -100), Vec2.of(100, -100), Vec2.of(7, 120) ],
+		],
+
+		// Points within a triangle (repeated vertex)
+		[
+			[ Vec2.of(28, 5), Vec2.of(4, 5), Vec2.of(-100, -100), Vec2.of(-100, -100), Vec2.of(7, 120), Vec2.of(1, 8), Vec2.of(100, -100), Vec2.of(2, 4), Vec2.of(3, 4), Vec2.of(4, 5) ],
+			[ Vec2.of(-100, -100), Vec2.of(100, -100), Vec2.of(7, 120) ],
+		],
+
+		// Points within a square
+		[
+			[ Vec2.of(28, 5), Vec2.of(4, 5), Vec2.of(-100, -100), Vec2.of(100, 100), Vec2.of(7, 100), Vec2.of(1, 8), Vec2.of(-100, 100), Vec2.of(100, -100), Vec2.of(2, 4), Vec2.of(3, 4), Vec2.of(4, 5) ],
+			[ Vec2.of(-100, -100), Vec2.of(100, -100), Vec2.of(100, 100), Vec2.of(-100, 100) ],
+		],
+
+		[
+			Rect2.unitSquare.corners,
+			[ Vec2.of(1, 0), Vec2.of(1, 1), Vec2.of(0, 1), Vec2.of(0, 0) ],
+		]
+	])('should compute the convex hull of a set of points (%j)', (points, expected) => {
+		expect(convexHull2Of(points)).toMatchObject(expected);
+	});
+});