smig/excalidraw
1
0
Fork 0
mirror of https://github.com/excalidraw/excalidraw.git synced 2025-05-03 10:00:07 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Arc tests

Browse source
This commit is contained in:
Mark Tolmacs 2024-09-25 14:22:32 +02:00
parent f79fb899fc
commit 3fe73e79a6
No known key found for this signature in database
9 changed files with 80 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

13
packages/math/angle.test.ts Normal file
View file

@ -0,0 +1,13 @@
import { cartesian2Polar, polar, radians } from "./angle";
import { point } from "./point";
describe("cartesian to polar coordinate conversion", () => {
it("converts values properly", () => {
expect(cartesian2Polar(point(12, 5))).toEqual(
polar(13, radians(Math.atan(5 / 12))),
);
expect(cartesian2Polar(point(5, 5))).toEqual(
polar(5 * Math.sqrt(2), radians(Math.PI / 4)),
);
});
});

26
packages/math/arc.test.ts
View file

@ -1,6 +1,7 @@
import { radians } from "./angle";
import { arc, arcIncludesPoint } from "./arc";
import { arc, arcIncludesPoint, arcSegmentInterceptPoint } from "./arc";
import { point } from "./point";
import { segment } from "./segment";
describe("point on arc", () => {
it("should detect point on simple arc", () => {
@ -28,3 +29,26 @@ describe("point on arc", () => {
).toBe(false);
});
});
describe("intersection", () => {
it("should report correct interception point", () => {
expect(
arcSegmentInterceptPoint(
arc(point(0, 0), 1, radians(-Math.PI / 4), radians(Math.PI / 4)),
segment(point(2, 1), point(0, 0)),
),
).toEqual([point(0.894427190999916, 0.447213595499958)]);
});
it("should report both interception points when present", () => {
expect(
arcSegmentInterceptPoint(
arc(point(0, 0), 1, radians(-Math.PI / 4), radians(Math.PI / 4)),
segment(point(0.9, -2), point(0.9, 2)),
),
).toEqual([
point(0.9, -0.4358898943540668),
point(0.9, 0.4358898943540668),
]);
});
});

12
packages/math/arc.ts
View file

@ -6,11 +6,11 @@ import { PRECISION } from "./utils";
/**
* Constructs a symmetric arc defined by the originating circle radius
* the start angle and end angle with 0 radians being the "northest" point
* the start angle and end angle with 0 radians being the most "eastward" point
* of the circle.
*
* @param radius The radius of the circle this arc lies on
* @param startAngle The start angle with 0 radians being the "northest" point
* @param startAngle The start angle with 0 radians being the most "eastward" point
* @param endAngle The end angle with 0 radians being the "northest" point
* @returns The constructed symmetric arc
*/
@ -46,20 +46,20 @@ export function arcIncludesPoint<P extends GenericPoint>(
* Returns the intersection point(s) of a line segment represented by a start
* point and end point and a symmetric arc.
*/
export function interceptOfSymmetricArcAndSegment<Point extends GenericPoint>(
export function arcSegmentInterceptPoint<Point extends GenericPoint>(
a: Readonly<Arc<Point>>,
l: Readonly<Segment<Point>>,
s: Readonly<Segment<Point>>,
): Point[] {
return ellipseSegmentInterceptPoints(
ellipse(a.center, radians(0), a.radius, a.radius),
l,
s,
).filter((candidate) => {
const [candidateRadius, candidateAngle] = cartesian2Polar(
point(candidate[0] - a.center[0], candidate[1] - a.center[1]),
);
return a.startAngle < a.endAngle
? Math.abs(a.radius - candidateRadius) < 0.0000001 &&
? Math.abs(a.radius - candidateRadius) < PRECISION &&
a.startAngle <= candidateAngle &&
a.endAngle >= candidateAngle
: a.startAngle <= candidateAngle || a.endAngle >= candidateAngle;

27
packages/math/ellipse.test.ts
View file

@ -50,8 +50,31 @@ describe("point and ellipse", () => {
describe("line and ellipse", () => {
it("detects outside segment", () => {
const l = segment<GlobalPoint>(point(-100, 0), point(-10, 0));
const e = ellipse(point(0, 0), radians(0), 2, 2);
expect(ellipseSegmentInterceptPoints(e, l).length).toBe(0);
expect(
ellipseSegmentInterceptPoints(
e,
segment<GlobalPoint>(point(-100, 0), point(-10, 0)),
),
).toEqual([]);
expect(
ellipseSegmentInterceptPoints(
e,
segment<GlobalPoint>(point(-10, 0), point(10, 0)),
),
).toEqual([point(-2, 0), point(2, 0)]);
expect(
ellipseSegmentInterceptPoints(
e,
segment<GlobalPoint>(point(-10, -2), point(10, -2)),
),
).toEqual([point(0, -2)]);
expect(
ellipseSegmentInterceptPoints(
e,
segment<GlobalPoint>(point(0, -1), point(0, 1)),
),
).toEqual([]);
});
});

57
packages/math/ellipse.ts
View file

@ -82,63 +82,10 @@ export const ellipseTouchesPoint = <Point extends GenericPoint>(
ellipse: Ellipse<Point>,
threshold = PRECISION,
) => {
return distanceToEllipse(point, ellipse) <= threshold;
return ellipseDistance(point, ellipse) <= threshold;
};
export const ellipseFocusToCenter = <Point extends GenericPoint>(
ellipse: Ellipse<Point>,
) => {
const widthGreaterThanHeight = ellipse.halfWidth > ellipse.halfHeight;
const majorAxis = widthGreaterThanHeight
? ellipse.halfWidth * 2
: ellipse.halfHeight * 2;
const minorAxis = widthGreaterThanHeight
? ellipse.halfHeight * 2
: ellipse.halfWidth * 2;
return Math.sqrt(majorAxis ** 2 - minorAxis ** 2);
};
export const ellipseExtremes = <Point extends GenericPoint>(
ellipse: Ellipse<Point>,
) => {
const { center, angle } = ellipse;
const widthGreaterThanHeight = ellipse.halfWidth > ellipse.halfHeight;
const majorAxis = widthGreaterThanHeight
? ellipse.halfWidth * 2
: ellipse.halfHeight * 2;
const minorAxis = widthGreaterThanHeight
? ellipse.halfHeight * 2
: ellipse.halfWidth * 2;
const cos = Math.cos(angle);
const sin = Math.sin(angle);
const sqSum = majorAxis ** 2 + minorAxis ** 2;
const sqDiff = (majorAxis ** 2 - minorAxis ** 2) * Math.cos(2 * angle);
const yMax = Math.sqrt((sqSum - sqDiff) / 2);
const xAtYMax =
(yMax * sqSum * sin * cos) /
(majorAxis ** 2 * sin ** 2 + minorAxis ** 2 * cos ** 2);
const xMax = Math.sqrt((sqSum + sqDiff) / 2);
const yAtXMax =
(xMax * sqSum * sin * cos) /
(majorAxis ** 2 * cos ** 2 + minorAxis ** 2 * sin ** 2);
const centerVector = vectorFromPoint(center);
return [
vectorAdd(vector(xAtYMax, yMax), centerVector),
vectorAdd(vectorScale(vector(xAtYMax, yMax), -1), centerVector),
vectorAdd(vector(xMax, yAtXMax), centerVector),
vectorAdd(vector(xMax, yAtXMax), centerVector),
];
};
const distanceToEllipse = <Point extends GenericPoint>(
export const ellipseDistance = <Point extends GenericPoint>(
p: Point,
ellipse: Ellipse<Point>,
) => {

7
packages/math/segment.ts
View file

@ -1,8 +1,10 @@
import { invariant } from "../excalidraw/utils";
import {
isPoint,
pointCenter,
pointFromVector,
pointRotateRads,
pointsEqual,
} from "./point";
import type { GenericPoint, Segment, Radians } from "./types";
import { PRECISION } from "./utils";
@ -21,6 +23,11 @@ import {
* @returns The line segment delineated by the points
*/
export function segment<P extends GenericPoint>(a: P, b: P): Segment<P> {
invariant(
!pointsEqual(a, b),
"The start and end points of the segment cannot match",
);
return [a, b] as Segment<P>;
}