@tldraw/editor 5.4.0-next.ef99ab47e5ce → 5.4.0

package/src/lib/primitives/geometry/CubicBezier2d.test.ts

@@ -1,5 +1,175 @@
-describe('CubicBezier2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { Vec } from '../Vec'
+import { CubicBezier2d } from './CubicBezier2d'
+import { Polyline2d } from './Polyline2d'
+
+// A symmetric arch from (0, 0) to (100, 0) whose control points pull it up to y = 75 at t = 0.5
+const arch = (resolution?: number) =>
+	new CubicBezier2d({
+		start: new Vec(0, 0),
+		cp1: new Vec(0, 100),
+		cp2: new Vec(100, 100),
+		end: new Vec(100, 0),
+		resolution,
+	})
+
+// Control points on the line y = x, so the curve is the straight segment (0,0) -> (30,30)
+const straight = () =>
+	new CubicBezier2d({
+		start: new Vec(0, 0),
+		cp1: new Vec(10, 10),
+		cp2: new Vec(20, 20),
+		end: new Vec(30, 30),
+	})
+
+describe('CubicBezier2d construction', () => {
+	it('is an open, unfilled polyline', () => {
+		const b = arch()
+		expect(b).toBeInstanceOf(Polyline2d)
+		expect(b).toMatchObject({ isClosed: false, isFilled: false })
+	})
+})
+
+describe('CubicBezier2d.GetAtT', () => {
+	it('returns the end points at t = 0 and t = 1', () => {
+		expect(CubicBezier2d.GetAtT(arch(), 0)).toMatchObject({ x: 0, y: 0 })
+		expect(CubicBezier2d.GetAtT(arch(), 1)).toMatchObject({ x: 100, y: 0 })
+	})
+
+	it('returns the weighted control point average in between', () => {
+		// 0.125 a + 0.375 b + 0.375 c + 0.125 d
+		expect(CubicBezier2d.GetAtT(arch(), 0.5)).toMatchObject({ x: 50, y: 75 })
+		const p = CubicBezier2d.GetAtT(arch(), 0.4)
+		expect(p.x).toBeCloseTo(35.2)
+		expect(p.y).toBeCloseTo(72)
+	})
+})
+
+describe('CubicBezier2d.getVertices', () => {
+	it('samples resolution + 1 points along the curve', () => {
+		const { vertices } = arch()
+		expect(vertices.length).toBe(11)
+		expect(vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(vertices[5]).toMatchObject({ x: 50, y: 75 })
+		expect(vertices[10]).toMatchObject({ x: 100, y: 0 })
+	})
+
+	it('honours a custom resolution', () => {
+		const { vertices } = arch(4)
+		expect(vertices.length).toBe(5)
+		expect(vertices[2]).toMatchObject({ x: 50, y: 75 })
+	})
+
+	it('is symmetric for symmetric control points', () => {
+		const { vertices } = arch()
+		for (let i = 0; i < 5; i++) {
+			expect(vertices[i].x).toBeCloseTo(100 - vertices[10 - i].x)
+			expect(vertices[i].y).toBeCloseTo(vertices[10 - i].y)
+		}
+	})
+})
+
+describe('CubicBezier2d.bounds', () => {
+	it('spans the sampled vertices', () => {
+		expect(arch().bounds).toMatchObject({ x: 0, y: 0, w: 100, h: 75 })
+		expect(arch().center).toMatchObject({ x: 50, y: 37.5 })
+	})
+})
+
+describe('CubicBezier2d.getLength', () => {
+	it('equals the chord for a straight curve', () => {
+		expect(straight().length).toBeCloseTo(Math.hypot(30, 30))
+	})
+
+	it('sums sampled chords at the given precision', () => {
+		const b = arch()
+		expect(b.getLength(undefined, 1)).toBe(100)
+		expect(b.getLength(undefined, 2)).toBeCloseTo(2 * Math.hypot(50, 75))
+	})
+
+	it('gets longer with finer sampling of a curved path', () => {
+		const b = arch()
+		expect(b.getLength(undefined, 2)).toBeLessThan(b.getLength(undefined, 32))
+		expect(b.length).toBe(b.getLength(undefined, 32))
+	})
+})
+
+describe('CubicBezier2d.nearestPoint', () => {
+	it('returns the peak vertex for a point above the arch', () => {
+		expect(arch().nearestPoint(new Vec(50, 100))).toMatchObject({ x: 50, y: 75 })
+	})
+
+	it('clamps to the end points', () => {
+		expect(arch().nearestPoint(new Vec(-10, 0))).toMatchObject({ x: 0, y: 0 })
+		expect(arch().nearestPoint(new Vec(110, 0))).toMatchObject({ x: 100, y: 0 })
+	})
+
+	it('projects onto the straight curve', () => {
+		const p = straight().nearestPoint(new Vec(20, 10))
+		expect(p.x).toBeCloseTo(15)
+		expect(p.y).toBeCloseTo(15)
+	})
+})
+
+describe('CubicBezier2d.distanceToPoint', () => {
+	it('measures to the sampled polyline', () => {
+		expect(arch().distanceToPoint(new Vec(50, 100))).toBe(25)
+		expect(arch().distanceToPoint(new Vec(-10, 0))).toBe(10)
+		expect(straight().distanceToPoint(new Vec(20, 10))).toBeCloseTo(Math.hypot(5, 5))
+	})
+
+	it('is always positive, even under the arch with hitInside', () => {
+		expect(arch().distanceToPoint(new Vec(50, 30), true)).toBeGreaterThan(0)
+	})
+})
+
+describe('CubicBezier2d.hitTestPoint', () => {
+	it('hits points on the curve', () => {
+		expect(arch().hitTestPoint(new Vec(50, 75))).toBe(true)
+		expect(arch().hitTestPoint(new Vec(0, 0))).toBe(true)
+	})
+
+	it('respects the margin', () => {
+		expect(arch().hitTestPoint(new Vec(50, 80), 5)).toBe(true)
+		expect(arch().hitTestPoint(new Vec(50, 80), 4)).toBe(false)
+	})
+
+	it('does not hit the area under the arch', () => {
+		expect(arch().hitTestPoint(new Vec(50, 30))).toBe(false)
+		expect(arch().hitTestPoint(new Vec(50, 30), 0, true)).toBe(false)
+	})
+})
+
+describe('CubicBezier2d.hitTestLineSegment', () => {
+	it('hits a segment crossing the curve', () => {
+		expect(arch().hitTestLineSegment(new Vec(50, 0), new Vec(50, 100))).toBe(true)
+	})
+
+	it('misses a segment away from the curve', () => {
+		expect(arch().hitTestLineSegment(new Vec(200, 0), new Vec(200, 100))).toBe(false)
+	})
+
+	it('respects the distance', () => {
+		expect(arch().hitTestLineSegment(new Vec(0, 80), new Vec(100, 80), 5)).toBe(true)
+		expect(arch().hitTestLineSegment(new Vec(0, 80), new Vec(100, 80), 4)).toBe(false)
+	})
+})
+
+describe('CubicBezier2d.getSvgPathData', () => {
+	it('emits a move and a cubic command', () => {
+		expect(arch().getSvgPathData()).toBe('M 0, 0  C0, 100 100, 100 100, 0')
+	})
+
+	it('omits the move command when not first', () => {
+		expect(arch().getSvgPathData(false)).toBe(' C0, 100 100, 100 100, 0')
+	})
+
+	it('rounds coordinates to two decimals', () => {
+		const b = new CubicBezier2d({
+			start: new Vec(0.123, 0),
+			cp1: new Vec(1.006, 2),
+			cp2: new Vec(3, 4.999),
+			end: new Vec(10, 10),
+		})
+		expect(b.getSvgPathData()).toBe('M 0.12, 0  C1.01, 2 3, 5 10, 10')
 	})
 })

package/src/lib/primitives/geometry/CubicSpline2d.test.ts

@@ -1,5 +1,162 @@
-describe('CubicSpline2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { Vec } from '../Vec'
+import { CubicBezier2d } from './CubicBezier2d'
+import { CubicSpline2d } from './CubicSpline2d'
+
+// Three collinear points: the spline is the straight line from (0, 0) to (200, 0)
+const line = () => new CubicSpline2d({ points: [new Vec(0, 0), new Vec(100, 0), new Vec(200, 0)] })
+
+// A symmetric peak: (0, 0) up to (100, 100) and back down to (200, 0)
+const peak = () =>
+	new CubicSpline2d({ points: [new Vec(0, 0), new Vec(100, 100), new Vec(200, 0)] })
+
+function expectVec(actual: Vec, expected: { x: number; y: number }) {
+	expect(actual.x).toBeCloseTo(expected.x)
+	expect(actual.y).toBeCloseTo(expected.y)
+}
+
+describe('CubicSpline2d construction', () => {
+	it('is never closed or filled', () => {
+		expect(line()).toMatchObject({ isClosed: false, isFilled: false })
+	})
+})
+
+describe('CubicSpline2d.segments', () => {
+	it('creates one bezier per pair of consecutive points', () => {
+		const { segments } = line()
+		expect(segments.length).toBe(2)
+		expect(segments[0]).toBeInstanceOf(CubicBezier2d)
+		expect(segments[0].vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(segments[0].vertices[10]).toMatchObject({ x: 100, y: 0 })
+		expect(segments[1].vertices[0]).toMatchObject({ x: 100, y: 0 })
+		expect(segments[1].vertices[10]).toMatchObject({ x: 200, y: 0 })
+	})
+
+	it('uses the end points as control points at the ends and Catmull-Rom style tangents between', () => {
+		const { segments } = peak()
+		// cp1 of the first segment is the first point; cp2 is pulled back from the second point
+		// along the chord (p3 - p1) / 6 * 1.25
+		expect(segments[0].getSvgPathData()).toBe('M 0, 0  C0, 0 58.33, 100 100, 100')
+		expect(segments[1].getSvgPathData()).toBe('M 100, 100  C141.67, 100 200, 0 200, 0')
+	})
+
+	it('caches the segments', () => {
+		const s = line()
+		expect(s.segments).toBe(s.segments)
+	})
+
+	it('creates a single straight segment for two points', () => {
+		const s = new CubicSpline2d({ points: [new Vec(0, 0), new Vec(100, 0)] })
+		expect(s.segments.length).toBe(1)
+		expect(s.segments[0].getSvgPathData()).toBe('M 0, 0  C0, 0 100, 0 100, 0')
+		expect(s.length).toBeCloseTo(100)
+	})
+
+	it('has no segments for a single point', () => {
+		const s = new CubicSpline2d({ points: [new Vec(5, 5)] })
+		expect(s.segments).toEqual([])
+		expect(s.vertices).toEqual([new Vec(5, 5)])
+		expect(s.length).toBe(0)
+		expect(() => s.nearestPoint(new Vec(0, 0))).toThrow('nearest point not found')
+	})
+})
+
+describe('CubicSpline2d.getVertices', () => {
+	it('concatenates the segment vertices and appends the final point', () => {
+		const { vertices } = line()
+		expect(vertices.length).toBe(11 + 11 + 1)
+		expect(vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(vertices[10]).toMatchObject({ x: 100, y: 0 })
+		expect(vertices[11]).toMatchObject({ x: 100, y: 0 })
+		expect(vertices[22]).toMatchObject({ x: 200, y: 0 })
+		for (const v of vertices) expect(v.y).toBe(0)
+	})
+
+	it('passes through every control point', () => {
+		const { vertices } = peak()
+		expect(vertices[0]).toMatchObject({ x: 0, y: 0 })
+		expect(vertices[10]).toMatchObject({ x: 100, y: 100 })
+		expect(vertices[22]).toMatchObject({ x: 200, y: 0 })
+	})
+})
+
+describe('CubicSpline2d.bounds', () => {
+	it('spans the vertices', () => {
+		expect(line().bounds).toMatchObject({ x: 0, y: 0, w: 200, h: 0 })
+		expect(peak().bounds).toMatchObject({ x: 0, y: 0, w: 200, h: 100 })
+		expect(peak().center).toMatchObject({ x: 100, y: 50 })
+	})
+})
+
+describe('CubicSpline2d.getLength', () => {
+	it('sums the segment lengths', () => {
+		const s = line()
+		expect(s.length).toBeCloseTo(200)
+		expect(s.length).toBeCloseTo(s.segments[0].length + s.segments[1].length)
+	})
+
+	it('is longer than the chord for a curved spline', () => {
+		expect(peak().length).toBeGreaterThan(2 * Math.hypot(100, 100))
+	})
+})
+
+describe('CubicSpline2d.nearestPoint', () => {
+	it('projects onto the nearest segment', () => {
+		expectVec(line().nearestPoint(new Vec(50, 10)), { x: 50, y: 0 })
+		expectVec(line().nearestPoint(new Vec(150, -10)), { x: 150, y: 0 })
+	})
+
+	it('clamps to the end points', () => {
+		expect(line().nearestPoint(new Vec(-10, 0))).toMatchObject({ x: 0, y: 0 })
+		expect(line().nearestPoint(new Vec(210, 5))).toMatchObject({ x: 200, y: 0 })
+	})
+
+	it('returns the shared point where two segments meet', () => {
+		expect(peak().nearestPoint(new Vec(100, 120))).toMatchObject({ x: 100, y: 100 })
+	})
+})
+
+describe('CubicSpline2d.distanceToPoint', () => {
+	it('is the distance to the nearest segment', () => {
+		expect(line().distanceToPoint(new Vec(50, 10))).toBeCloseTo(10)
+		expect(line().distanceToPoint(new Vec(150, -10))).toBeCloseTo(10)
+		expect(peak().distanceToPoint(new Vec(100, 120))).toBe(20)
+	})
+
+	it('is never negative', () => {
+		expect(peak().distanceToPoint(new Vec(100, 50), true)).toBeGreaterThan(0)
+	})
+})
+
+describe('CubicSpline2d.hitTestPoint', () => {
+	it('hits points on the spline within the margin', () => {
+		expect(line().hitTestPoint(new Vec(50, 0), 0.001)).toBe(true)
+		expect(line().hitTestPoint(new Vec(50, 10), 10)).toBe(true)
+		expect(line().hitTestPoint(new Vec(50, 10), 9)).toBe(false)
+	})
+
+	it('does not hit the area under a peak', () => {
+		expect(peak().hitTestPoint(new Vec(100, 50), 0, true)).toBe(false)
+	})
+})
+
+describe('CubicSpline2d.hitTestLineSegment', () => {
+	it('hits a segment crossing either bezier', () => {
+		expect(line().hitTestLineSegment(new Vec(50, -10), new Vec(50, 10))).toBe(true)
+		expect(line().hitTestLineSegment(new Vec(150, -10), new Vec(150, 10))).toBe(true)
+	})
+
+	it('misses a segment that does not reach the spline', () => {
+		expect(line().hitTestLineSegment(new Vec(150, 5), new Vec(150, 10))).toBe(false)
+		expect(line().hitTestLineSegment(new Vec(250, -10), new Vec(250, 10))).toBe(false)
+	})
+})
+
+describe('CubicSpline2d.getSvgPathData', () => {
+	it('chains the segment paths with a single move command', () => {
+		expect(line().getSvgPathData()).toBe('M 0, 0  C0, 0 58.33, 0 100, 0 C141.67, 0 200, 0 200, 0')
+	})
+
+	it('is empty for a single point', () => {
+		expect(new CubicSpline2d({ points: [new Vec(5, 5)] }).getSvgPathData()).toBe('')
 	})
 })

package/src/lib/primitives/geometry/Ellipse2d.test.ts

@@ -1,5 +1,245 @@
-describe('Ellipse2d', () => {
-	it('should be tested', () => {
-		expect(true).toBe(true)
+import { perimeterOfEllipse } from '../utils'
+import { Vec } from '../Vec'
+import { Edge2d } from './Edge2d'
+import { Ellipse2d } from './Ellipse2d'
+import { getVerticesCountForArcLength } from './geometry-constants'
+
+// A 100x50 ellipse: centre (50, 25), rx = 50, ry = 25
+const ellipse = () => new Ellipse2d({ width: 100, height: 50, isFilled: false })
+const filled = () => new Ellipse2d({ width: 100, height: 50, isFilled: true })
+
+function expectOnEllipse(p: Vec, cx: number, cy: number, rx: number, ry: number) {
+	const dx = (p.x - cx) / rx
+	const dy = (p.y - cy) / ry
+	expect(dx * dx + dy * dy).toBeCloseTo(1, 6)
+}
+
+describe('Ellipse2d construction', () => {
+	it('is always closed and keeps the fill flag from config', () => {
+		expect(ellipse()).toMatchObject({ isClosed: true, isFilled: false })
+		expect(filled()).toMatchObject({ isClosed: true, isFilled: true })
+	})
+
+	it('passes through the other geometry options', () => {
+		const e = new Ellipse2d({
+			width: 10,
+			height: 10,
+			isFilled: true,
+			isLabel: true,
+			isInternal: true,
+			debugColor: 'red',
+			ignore: true,
+			excludeFromShapeBounds: true,
+		})
+		expect(e).toMatchObject({
+			isLabel: true,
+			isInternal: true,
+			debugColor: 'red',
+			ignore: true,
+			excludeFromShapeBounds: true,
+		})
+	})
+})
+
+describe('Ellipse2d.getVertices', () => {
+	it('samples one vertex per 20 units of perimeter, starting at the rightmost point', () => {
+		const e = ellipse()
+		const { vertices } = e
+		expect(vertices.length).toBe(getVerticesCountForArcLength(perimeterOfEllipse(50, 25)))
+		expect(vertices.length).toBe(13)
+		expect(vertices[0]).toMatchObject({ x: 100, y: 25 })
+	})
+
+	it('places every vertex on the ellipse and inside the bounds', () => {
+		const { vertices, bounds } = ellipse()
+		for (const v of vertices) {
+			expectOnEllipse(v, 50, 25, 50, 25)
+			expect(bounds.containsPoint(v)).toBe(true)
+		}
+	})
+
+	it('walks the ellipse in the positive angular direction', () => {
+		const { vertices } = ellipse()
+		// second vertex is one step (2π/13) clockwise in screen space, so below the first
+		expect(vertices[1].x).toBeLessThan(100)
+		expect(vertices[1].y).toBeGreaterThan(25)
+	})
+
+	it('falls back to the minimum vertex count for a tiny ellipse', () => {
+		const { vertices } = new Ellipse2d({ width: 1, height: 1, isFilled: false })
+		expect(vertices.length).toBe(8)
+	})
+
+	it('does not produce NaNs for a zero size ellipse', () => {
+		const e = new Ellipse2d({ width: 0, height: 0, isFilled: false })
+		expect(e.vertices.length).toBe(8)
+		for (const v of e.vertices) {
+			expect(Number.isFinite(v.x)).toBe(true)
+			expect(Number.isFinite(v.y)).toBe(true)
+		}
+		expect(e.bounds).toMatchObject({ x: 0, y: 0, w: 0, h: 0 })
+	})
+
+	it('has a NaN length for a zero size ellipse (known quirk)', () => {
+		// perimeterOfEllipse divides by (rx + ry) ** 2, which is zero here
+		expect(new Ellipse2d({ width: 0, height: 0, isFilled: false }).getLength()).toBeNaN()
+	})
+})
+
+describe('Ellipse2d.edges', () => {
+	it('connects consecutive vertices and closes back to the first', () => {
+		const e = ellipse()
+		const { edges, vertices } = e
+		expect(edges.length).toBe(vertices.length)
+		expect(edges[0]).toBeInstanceOf(Edge2d)
+		expect(edges[0].vertices).toEqual([vertices[0], vertices[1]])
+		expect(edges[edges.length - 1].vertices).toEqual([vertices[vertices.length - 1], vertices[0]])
+	})
+
+	it('caches the edges', () => {
+		const e = ellipse()
+		expect(e.edges).toBe(e.edges)
+	})
+})
+
+describe('Ellipse2d.bounds', () => {
+	it('is the width by height box at the origin', () => {
+		expect(ellipse().bounds).toMatchObject({ x: 0, y: 0, w: 100, h: 50 })
+		expect(ellipse().center).toMatchObject({ x: 50, y: 25 })
+	})
+
+	it('is not affected by the polygon approximation', () => {
+		// the bounds come from the config, not from the sampled vertices
+		const e = new Ellipse2d({ width: 3, height: 7, isFilled: false })
+		expect(e.bounds).toMatchObject({ x: 0, y: 0, w: 3, h: 7 })
+	})
+})
+
+describe('Ellipse2d.getLength', () => {
+	it("uses Ramanujan's perimeter approximation", () => {
+		expect(ellipse().length).toBeCloseTo(242.21, 1)
+		expect(ellipse().length).toBeCloseTo(perimeterOfEllipse(50, 25))
+	})
+
+	it('matches a circle circumference when width equals height', () => {
+		expect(new Ellipse2d({ width: 100, height: 100, isFilled: false }).length).toBeCloseTo(
+			Math.PI * 100
+		)
+	})
+})
+
+describe('Ellipse2d.area', () => {
+	it('is the area of the inscribed polygon', () => {
+		const e = ellipse()
+		const n = e.vertices.length
+		expect(e.area).toBeCloseTo((n / 2) * 50 * 25 * Math.sin((2 * Math.PI) / n), 5)
+		expect(e.area).toBeLessThan(Math.PI * 50 * 25)
+	})
+})
+
+describe('Ellipse2d.nearestPoint', () => {
+	it('returns the vertex when it is the nearest point', () => {
+		expect(ellipse().nearestPoint(new Vec(150, 25))).toMatchObject({ x: 100, y: 25 })
+	})
+
+	it('returns a point on the edge polygon nearest to the point', () => {
+		const e = ellipse()
+		const p = e.nearestPoint(new Vec(50, -10))
+		expect(Vec.Dist(p, new Vec(50, 0))).toBeLessThan(1.5)
+		expect(e.hitTestPoint(p, 0.001)).toBe(true)
+	})
+
+	it('accepts plain objects', () => {
+		expect(ellipse().nearestPoint({ x: 150, y: 25 })).toMatchObject({ x: 100, y: 25 })
+	})
+})
+
+describe('Ellipse2d.distanceToPoint', () => {
+	it('is positive outside', () => {
+		expect(ellipse().distanceToPoint(new Vec(150, 25))).toBe(50)
+		expect(filled().distanceToPoint(new Vec(150, 25))).toBe(50)
+	})
+
+	it('is zero on a vertex', () => {
+		expect(ellipse().distanceToPoint(new Vec(100, 25))).toBe(0)
+	})
+
+	it('is negative inside only when filled or hitInside', () => {
+		const unfilledDist = ellipse().distanceToPoint(new Vec(50, 25))
+		expect(unfilledDist).toBeGreaterThan(0)
+		expect(filled().distanceToPoint(new Vec(50, 25))).toBe(-unfilledDist)
+		expect(ellipse().distanceToPoint(new Vec(50, 25), true)).toBe(-unfilledDist)
+	})
+})
+
+describe('Ellipse2d.hitTestPoint', () => {
+	it('hits the interior only when filled or hitInside', () => {
+		expect(filled().hitTestPoint(new Vec(50, 25))).toBe(true)
+		expect(ellipse().hitTestPoint(new Vec(50, 25))).toBe(false)
+		expect(ellipse().hitTestPoint(new Vec(50, 25), 0, true)).toBe(true)
+	})
+
+	it('misses points outside', () => {
+		expect(filled().hitTestPoint(new Vec(150, 25))).toBe(false)
+		expect(ellipse().hitTestPoint(new Vec(150, 25))).toBe(false)
+	})
+
+	it('misses the bounding box corners, which are outside the ellipse', () => {
+		expect(filled().hitTestPoint(new Vec(1, 1))).toBe(false)
+		expect(filled().hitTestPoint(new Vec(99, 49))).toBe(false)
+	})
+
+	it('hits the edge', () => {
+		expect(ellipse().hitTestPoint(new Vec(100, 25))).toBe(true)
+	})
+
+	it('respects the margin', () => {
+		expect(ellipse().hitTestPoint(new Vec(105, 25), 5)).toBe(true)
+		expect(ellipse().hitTestPoint(new Vec(105, 25), 4)).toBe(false)
+		expect(ellipse().hitTestPoint(new Vec(95, 25), 5)).toBe(true)
+	})
+})
+
+describe('Ellipse2d.hitTestLineSegment', () => {
+	it('hits a segment crossing the edge', () => {
+		expect(ellipse().hitTestLineSegment(new Vec(50, -10), new Vec(50, 60))).toBe(true)
+		expect(ellipse().hitTestLineSegment(new Vec(90, 25), new Vec(110, 25))).toBe(true)
+	})
+
+	it('misses a segment entirely outside', () => {
+		expect(ellipse().hitTestLineSegment(new Vec(150, 0), new Vec(150, 50))).toBe(false)
+	})
+
+	it('misses a segment entirely inside, even when filled', () => {
+		expect(ellipse().hitTestLineSegment(new Vec(40, 25), new Vec(60, 25))).toBe(false)
+		expect(filled().hitTestLineSegment(new Vec(40, 25), new Vec(60, 25))).toBe(false)
+	})
+
+	it('misses a segment that cuts through a bounding box corner only', () => {
+		expect(ellipse().hitTestLineSegment(new Vec(0, 0), new Vec(5, 5))).toBe(false)
+	})
+})
+
+describe('Ellipse2d.intersectLineSegment', () => {
+	it('returns both crossings of a horizontal line through the centre', () => {
+		const hits = ellipse().intersectLineSegment(new Vec(-10, 25), new Vec(110, 25))
+		expect(hits.length).toBe(2)
+		expect(hits.map((h) => h.y)).toEqual([25, 25])
+		const xs = hits.map((h) => h.x).sort((a, b) => a - b)
+		// the leftmost point is not a vertex, so the polygon edge sits slightly inside the ellipse
+		expect(xs[0]).toBeGreaterThanOrEqual(0)
+		expect(xs[0]).toBeLessThan(2)
+		expect(xs[1]).toBe(100)
+	})
+})
+
+describe('Ellipse2d.getSvgPathData', () => {
+	it('draws two arcs starting from the leftmost point', () => {
+		expect(ellipse().getSvgPathData(true)).toBe('M0,25 a50,25,0,1,1,100,0a50,25,0,1,1,-100,0')
+	})
+
+	it('omits the move command when not first', () => {
+		expect(ellipse().getSvgPathData()).toBe(' a50,25,0,1,1,100,0a50,25,0,1,1,-100,0')
+		expect(ellipse().getSvgPathData(false)).toBe(ellipse().getSvgPathData())
 	})
 })