ducjs 1.0.0

package/dist/utils/math/algebra/galines.js

@@ -0,0 +1,32 @@
+import * as GA from "ducjs/utils/math/algebra/ga";
+/**
+ * A line is stored as an array `[0, c, a, b, 0, 0, 0, 0]` representing:
+ *   c * e0 + a * e1 + b*e2
+ *
+ * This maps to a standard formula `a * x + b * y + c`.
+ *
+ * `(-b, a)` corresponds to a 2D vector parallel to the line. The lines
+ * have a natural orientation, corresponding to that vector.
+ *
+ * The magnitude ("norm") of the line is `sqrt(a ^ 2 + b ^ 2)`.
+ * `c / norm(line)` is the oriented distance from line to origin.
+ */
+// Returns line with direction (x, y) through origin
+export const vector = (x, y) => GA.normalized([0, 0, -y, x, 0, 0, 0, 0]);
+// For equation ax + by + c = 0.
+export const equation = (a, b, c) => GA.normalized([0, c, a, b, 0, 0, 0, 0]);
+export const through = (from, to) => GA.normalized(GA.join(to, from));
+export const orthogonal = (line, point) => GA.dot(line, point);
+// Returns a line perpendicular to the line through `against` and `intersection`
+// going through `intersection`.
+export const orthogonalThrough = (against, intersection) => orthogonal(through(against, intersection), intersection);
+export const parallel = (line, distance) => {
+    const result = line.slice();
+    result[1] -= distance;
+    return result;
+};
+export const parallelThrough = (line, point) => orthogonal(orthogonal(point, line), point);
+export const distance = (line1, line2) => GA.inorm(GA.meet(line1, line2));
+export const angle = (line1, line2) => Math.acos(GA.dot(line1, line2)[0]);
+// The orientation of the line
+export const sign = (line) => Math.sign(line[1]);

package/dist/utils/math/algebra/gapoints.d.ts

@@ -0,0 +1,8 @@
+import type { GAPoint, GALine } from "ducjs/utils/math/algebra/ga";
+export declare const fromPoint: ([x, y]: readonly [number, number]) => GAPoint;
+export declare const toTuple: (point: GAPoint) => [number, number];
+export declare const abs: (point: GAPoint) => GAPoint;
+export declare const intersect: (line1: GALine, line2: GALine) => GAPoint;
+export declare const project: (point: GAPoint, line: GALine) => GAPoint;
+export declare const fromDistance: (point1: GAPoint, point2: GAPoint) => number;
+export declare const distanceToLine: (point: GAPoint, line: GALine) => number;

package/dist/utils/math/algebra/gapoints.js

@@ -0,0 +1,30 @@
+import * as GA from "ducjs/utils/math/algebra/ga";
+import * as GALines from "ducjs/utils/math/algebra/galines";
+import { join } from "ducjs/utils/math/algebra/ga";
+export const fromPoint = ([x, y]) => [
+    0,
+    0,
+    0,
+    0,
+    y,
+    x,
+    1,
+    0,
+];
+export const toTuple = (point) => [point[5], point[4]];
+export const abs = (point) => [
+    0,
+    0,
+    0,
+    0,
+    Math.abs(point[4]),
+    Math.abs(point[5]),
+    1,
+    0,
+];
+export const intersect = (line1, line2) => GA.normalized(GA.meet(line1, line2));
+// Projects `point` onto the `line`.
+// The returned point is the closest point on the `line` to the `point`.
+export const project = (point, line) => intersect(GALines.orthogonal(line, point), line);
+export const fromDistance = (point1, point2) => GA.norm(join(point1, point2));
+export const distanceToLine = (point, line) => GA.joinScalar(point, line);

package/dist/utils/math/algebra/gatransforms.d.ts

@@ -0,0 +1,10 @@
+import type { GALine, GADirection, GAPoint, GATransform } from "ducjs/utils/math/algebra/ga";
+/**
+ * TODO: docs
+ */
+export declare const rotation: (pivot: GAPoint, angle: number) => GATransform;
+export declare const translation: (direction: GADirection) => GATransform;
+export declare const translationOrthogonal: (direction: GADirection, distance: number) => GATransform;
+export declare const translationAlong: (line: GALine, distance: number) => GATransform;
+export declare const compose: (motor1: GATransform, motor2: GATransform) => GATransform;
+export declare const apply: (motor: GATransform, nvector: GAPoint | GADirection | GALine) => GAPoint | GADirection | GALine;

package/dist/utils/math/algebra/gatransforms.js

@@ -0,0 +1,23 @@
+import * as GA from "ducjs/utils/math/algebra/ga";
+import * as GADirections from "ducjs/utils/math/algebra/gadirections";
+/**
+ * TODO: docs
+ */
+export const rotation = (pivot, angle) => GA.add(GA.mul(pivot, Math.sin(angle / 2)), Math.cos(angle / 2));
+export const translation = (direction) => [
+    1,
+    0,
+    0,
+    0,
+    -(0.5 * direction[5]),
+    0.5 * direction[4],
+    0,
+    0,
+];
+export const translationOrthogonal = (direction, distance) => {
+    const scale = 0.5 * distance;
+    return [1, 0, 0, 0, scale * direction[4], scale * direction[5], 0, 0];
+};
+export const translationAlong = (line, distance) => GA.add(GA.mul(GADirections.orthogonalToLine(line), 0.5 * distance), 1);
+export const compose = (motor1, motor2) => GA.mul(motor2, motor1);
+export const apply = (motor, nvector) => GA.normalized(GA.mul(GA.mul(motor, nvector), GA.reverse(motor)));

package/dist/utils/math/algebra/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./gapoints";
+export * from "./gatransforms";
+export * from "./gadirections";
+export * from "./galines";
+export * from "./ga";

package/dist/utils/math/algebra/index.js

@@ -0,0 +1,5 @@
+export * from "./gapoints";
+export * from "./gatransforms";
+export * from "./gadirections";
+export * from "./galines";
+export * from "./ga";

package/dist/utils/math/bbox.d.ts

@@ -0,0 +1,10 @@
+import { Bounds, LineSegment } from "ducjs/types/geometryTypes";
+import { GeometricPoint } from "ducjs/types/geometryTypes";
+export declare function getBBox(line: LineSegment): Bounds;
+export declare function crossProduct(a: GeometricPoint, b: GeometricPoint): number;
+export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
+export declare function translate(a: GeometricPoint, b: GeometricPoint): GeometricPoint;
+export declare function isPointOnLine(l: LineSegment, p: GeometricPoint): boolean;
+export declare function isPointRightOfLine(l: LineSegment, p: GeometricPoint): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine(a: LineSegment, b: LineSegment): boolean;
+export declare function doLineSegmentsIntersect(a: LineSegment, b: LineSegment): boolean;

package/dist/utils/math/bbox.js

@@ -0,0 +1,42 @@
+export function getBBox(line) {
+    return [
+        Math.min(line[0].x, line[1].x),
+        Math.min(line[0].y, line[1].y),
+        Math.max(line[0].x, line[1].x),
+        Math.max(line[0].y, line[1].y),
+    ];
+}
+export function crossProduct(a, b) {
+    return a.x * b.y - b.x * a.y;
+}
+export function doBBoxesIntersect(a, b) {
+    return a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];
+}
+export function translate(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y };
+}
+const EPSILON = 0.000001;
+export function isPointOnLine(l, p) {
+    const p1 = translate(l[1], l[0]);
+    const p2 = translate(p, l[0]);
+    const r = crossProduct(p1, p2);
+    return Math.abs(r) < EPSILON;
+}
+export function isPointRightOfLine(l, p) {
+    const p1 = translate(l[1], l[0]);
+    const p2 = translate(p, l[0]);
+    return crossProduct(p1, p2) < 0;
+}
+export function isLineSegmentTouchingOrCrossingLine(a, b) {
+    return (isPointOnLine(a, b[0]) ||
+        isPointOnLine(a, b[1]) ||
+        (isPointRightOfLine(a, b[0])
+            ? !isPointRightOfLine(a, b[1])
+            : isPointRightOfLine(a, b[1])));
+}
+// https://martin-thoma.com/how-to-check-if-two-line-segments-intersect/
+export function doLineSegmentsIntersect(a, b) {
+    return (doBBoxesIntersect(getBBox(a), getBBox(b)) &&
+        isLineSegmentTouchingOrCrossingLine(a, b) &&
+        isLineSegmentTouchingOrCrossingLine(b, a));
+}

package/dist/utils/math/geometry.d.ts

@@ -0,0 +1,102 @@
+/**
+ * This file defines pure geometric shapes
+ *
+ * For instance, a cubic bezier curve is specified by its four control points and
+ * an ellipse is defined by its center, angle, semi-major axis, and semi-minor axis
+ * (but in halfWidth and halfHeight instead, so it's more relevant to Duc).
+ *
+ * The idea with pure shapes is so that we can provide collision and other geometric methods not depending on
+ * the specifics of roughjs or elements in Duc; instead, we can focus on the pure shapes themselves.
+ *
+ * Also included in this file are methods for converting a Duc element or a Drawable from roughjs
+ * to pure shapes.
+ */
+import type { DucBindableElement } from "ducjs/types/elements";
+import type { LineSegment } from "ducjs/types/geometryTypes";
+import type { GeometricPoint, Line, Polygon, Curve, Ellipse, Polycurve, Polyline } from "ducjs/types/geometryTypes";
+/**
+ * Utils
+ */
+export declare const cross: (a: Readonly<GeometricPoint>, b: Readonly<GeometricPoint>, o: Readonly<GeometricPoint>) => number;
+export declare const geometryDot: (a: Readonly<GeometricPoint>, b: Readonly<GeometricPoint>, o: Readonly<GeometricPoint>) => number;
+export declare const isClosed: (polygon: Polygon) => boolean;
+export declare const close: (polygon: Polygon) => Polygon;
+/**
+ * Angles
+ */
+export declare const angleToDegrees: (angle: number) => number;
+export declare const angleToRadians: (angle: number) => number;
+export declare const angleReflect: (incidenceAngle: number, surfaceAngle: number) => number;
+export declare const pointRotate: (point: GeometricPoint, angle: number, origin?: GeometricPoint) => GeometricPoint;
+export declare const pointTranslate: (point: GeometricPoint, angle?: number, distance?: number) => GeometricPoint;
+export declare const pointInverse: (point: GeometricPoint) => GeometricPoint;
+export declare const pointAdd: (pointA: GeometricPoint, pointB: GeometricPoint) => GeometricPoint;
+export declare const distanceToPoint: (p1: GeometricPoint, p2: GeometricPoint) => number;
+/**
+ * Lines
+ */
+export declare const lineAngle: (line: Line) => number;
+export declare const lineLength: (line: Line) => number;
+export declare const lineMidpoint: (line: Line) => GeometricPoint;
+export declare const lineRotate: (line: Line, angle: number, origin?: GeometricPoint) => Line;
+export declare const lineTranslate: (line: Line, angle: number, distance: number) => GeometricPoint[];
+export declare const lineInterpolate: (line: Line, clamp?: boolean) => (t: number) => GeometricPoint;
+export declare const curveToBezier: (pointsIn: readonly GeometricPoint[], curveTightness?: number) => GeometricPoint[];
+export declare const curveRotate: (curve: Curve, angle: number, origin: GeometricPoint) => GeometricPoint[];
+export declare const cubicBezierPoint: (t: number, controlPoints: Curve) => GeometricPoint;
+export declare const cubicBezierDistance: (point: GeometricPoint, controlPoints: Curve) => number;
+/**
+ * Polygons
+ */
+export declare const polygonRotate: (polygon: Polygon, angle: number, origin: GeometricPoint) => GeometricPoint[];
+export declare const polygonBounds: (polygon: Polygon) => [GeometricPoint, GeometricPoint];
+export declare const polygonCentroid: (vertices: GeometricPoint[]) => GeometricPoint;
+export declare const polygonScale: (polygon: Polygon, scale: number, origin?: GeometricPoint) => Polygon;
+export declare const polygonScaleX: (polygon: Polygon, scale: number, origin?: GeometricPoint) => Polygon;
+export declare const polygonScaleY: (polygon: Polygon, scale: number, origin?: GeometricPoint) => Polygon;
+export declare const polygonReflectX: (polygon: Polygon, reflectFactor?: number) => GeometricPoint[];
+export declare const polygonReflectY: (polygon: Polygon, reflectFactor?: number) => GeometricPoint[];
+export declare const polygonTranslate: (polygon: Polygon, angle: number, distance: number) => GeometricPoint[];
+/**
+ * Ellipses
+ */
+export declare const ellipseAxes: (ellipse: Ellipse) => {
+    majorAxis: number;
+    minorAxis: number;
+};
+export declare const ellipseFocusToCenter: (ellipse: Ellipse) => number;
+export declare const ellipseExtremes: (ellipse: Ellipse) => GeometricPoint[];
+export declare const pointRelativeToCenter: (point: GeometricPoint, center: GeometricPoint, angle: number) => GeometricPoint;
+export declare const pointLeftofLine: (point: GeometricPoint, line: Line) => boolean;
+export declare const pointRightofLine: (point: GeometricPoint, line: Line) => boolean;
+export declare const distanceToSegment: (point: GeometricPoint, line: Line) => number;
+export declare const pointOnLine: (point: GeometricPoint, line: Line, threshold?: number) => boolean;
+export declare const pointOnPolyline: (point: GeometricPoint, polyline: Polyline, threshold?: number) => boolean;
+export declare const lineIntersectsLine: (lineA: Line, lineB: Line) => boolean;
+export declare const lineIntersectsPolygon: (line: Line, polygon: Polygon) => boolean;
+export declare const pointInBezierEquation: (p0: GeometricPoint, p1: GeometricPoint, p2: GeometricPoint, p3: GeometricPoint, { x: mx, y: my }: GeometricPoint, lineThreshold: number) => boolean;
+export declare const cubicBezierEquation: (curve: Curve) => (t: number, coord: "x" | "y") => number;
+export declare const polyLineFromCurve: (curve: Curve, segments?: number) => Polyline;
+export declare const pointOnCurve: (point: GeometricPoint, curve: Curve, threshold?: number) => boolean;
+export declare const pointOnPolycurve: (point: GeometricPoint, polycurve: Polycurve, threshold?: number) => boolean;
+export declare const pointInPolygon: (point: GeometricPoint, polygon: Polygon) => boolean;
+export declare const pointOnPolygon: (point: GeometricPoint, polygon: Polygon, threshold?: number) => boolean;
+export declare const polygonInPolygon: (polygonA: Polygon, polygonB: Polygon) => boolean;
+export declare const polygonIntersectPolygon: (polygonA: Polygon, polygonB: Polygon) => boolean;
+export declare const pointOnEllipse: (point: GeometricPoint, ellipse: Ellipse, threshold?: number) => boolean;
+export declare const pointInEllipse: (point: GeometricPoint, ellipse: Ellipse) => boolean;
+/**
+ * Segment Intersections
+ */
+export declare const segmentsIntersectAt: (a: Readonly<LineSegment>, b: Readonly<LineSegment>) => GeometricPoint | null;
+/**
+ * Determine intersection of a rectangular shaped element and a
+ * line segment.
+ *
+ * @param element The rectangular element to test against
+ * @param segment The segment intersecting the element
+ * @param gap Optional value to inflate the shape before testing
+ * @returns An array of intersections
+ */
+export declare const segmentIntersectRectangleElement: (element: DucBindableElement, segment: LineSegment, gap?: number) => GeometricPoint[];
+export declare function pointFrom<T extends GeometricPoint>(x: number, y: number): T;