feat(editor): place the « − » bubble on the open side of its vertex
This commit is contained in:
1 parent
d3f6314219
commit
aecc2b468e
2 files changed
+548
No files matched your search
@@ -0,0 +1,261 @@
|
||||
import type { Point } from '@faunosteo/core-wasm/types'
|
||||
import type { Frame, XY } from './frame'
|
||||
import type { HandleSizes } from './handleSize'
|
||||
|
||||
/** Where the bubble may lie, in drawing units, and what surrounds the chosen vertex. */
|
||||
export interface BubbleScene {
|
||||
points: readonly Point[]
|
||||
/** Segment i (vertex i to the next) shows its « + » (ZoneHandles.shownInserts). */
|
||||
inserts: readonly boolean[]
|
||||
/** Drawing units per CSS px. */
|
||||
unit: number
|
||||
sizes: HandleSizes
|
||||
/** Where the bubble may lie, in drawing units: the frame ∩ the part on screen; null: no bound. */
|
||||
bounds: Frame | null
|
||||
/** The whole frame: the bound used when the chosen vertex is off screen; null: none. */
|
||||
frame: Frame | null
|
||||
}
|
||||
|
||||
/** CSS px kept between the bubble's hit rect and its own vertex's hit circle. */
|
||||
const GAP_PX = 2
|
||||
/** Turns tried around the open direction (owner: 30° steps): 0, +30, −30, … ±150, 180. */
|
||||
const TURNS = [0, ...[1, 2, 3, 4, 5].flatMap((i) => [i, -i]), 6].map(
|
||||
(i) => (i * Math.PI) / 6,
|
||||
)
|
||||
/** CSS px tried farther out when no turn is clear (measured: 24 px suffice on the equine sheet). */
|
||||
const FARTHER_PX = [0, 8, 16, 24, 32]
|
||||
/** Float noise of the framing: a vertex on the edge of the screen is on screen (CSS px). */
|
||||
const EDGE_PX = 1e-3
|
||||
|
||||
/** What the search measures around the chosen vertex, all in CSS px relative to it. */
|
||||
interface Around {
|
||||
/** Midpoints of the shown « + ». */
|
||||
insertMids: XY[]
|
||||
/** The other distinct vertices. */
|
||||
vertices: XY[]
|
||||
}
|
||||
|
||||
interface Scored {
|
||||
centre: XY
|
||||
inside: boolean
|
||||
insertGap: number
|
||||
vertexGap: number
|
||||
unambiguous: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Signed px gap between the bubble's hit rect centred at `centre` and a hit circle at
|
||||
* `other` (both px).
|
||||
*/
|
||||
export function bubbleClearance(
|
||||
centre: XY,
|
||||
other: XY,
|
||||
sizes: HandleSizes,
|
||||
): number {
|
||||
const dx = Math.max(Math.abs(other.x - centre.x) - sizes.bubble.w / 2, 0)
|
||||
const dy = Math.max(Math.abs(other.y - centre.y) - sizes.bubble.h / 2, 0)
|
||||
return Math.hypot(dx, dy) - sizes.hit
|
||||
}
|
||||
|
||||
/**
|
||||
* The part of the frame on screen (drawing units), from the framing; null when the box
|
||||
* is 0 × 0.
|
||||
*/
|
||||
export function visibleBounds(
|
||||
frame: Frame,
|
||||
box: { w: number; h: number },
|
||||
framing: { x: number; y: number; scale: number },
|
||||
): Frame | null {
|
||||
if (box.w <= 0 || box.h <= 0) return null
|
||||
const base = Math.min(box.w / frame.w, box.h / frame.h)
|
||||
const ox = (box.w - frame.w * base) / 2
|
||||
const oy = (box.h - frame.h * base) / 2
|
||||
const toDrawing = (px: number, o: number, origin: number) =>
|
||||
origin + (px - o) / base
|
||||
const x0 = Math.max(
|
||||
frame.x,
|
||||
toDrawing(-framing.x / framing.scale, ox, frame.x),
|
||||
)
|
||||
const x1 = Math.min(
|
||||
frame.x + frame.w,
|
||||
toDrawing((box.w - framing.x) / framing.scale, ox, frame.x),
|
||||
)
|
||||
const y0 = Math.max(
|
||||
frame.y,
|
||||
toDrawing(-framing.y / framing.scale, oy, frame.y),
|
||||
)
|
||||
const y1 = Math.min(
|
||||
frame.y + frame.h,
|
||||
toDrawing((box.h - framing.y) / framing.scale, oy, frame.y),
|
||||
)
|
||||
return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }
|
||||
}
|
||||
|
||||
const samePoint = (a: Point, b: Point): boolean =>
|
||||
a[0] === b[0] && a[1] === b[1]
|
||||
|
||||
/** The first point, walking `step` (−1 or +1) from `chosen`, that differs from it. */
|
||||
function neighbour(
|
||||
points: readonly Point[],
|
||||
chosen: number,
|
||||
step: number,
|
||||
): Point | null {
|
||||
const n = points.length
|
||||
for (let k = 1; k < n; k++) {
|
||||
const p = points[(((chosen + step * k) % n) + n) % n]
|
||||
if (!samePoint(p, points[chosen])) return p
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/** The angle (radians) the bubble opens towards: away from the polygon's inside corner. */
|
||||
function openDirection(points: readonly Point[], chosen: number): number {
|
||||
const v = points[chosen]
|
||||
const before = neighbour(points, chosen, -1)
|
||||
const after = neighbour(points, chosen, 1)
|
||||
if (before === null || after === null) {
|
||||
const only = before ?? after
|
||||
if (only === null) return -Math.PI / 2
|
||||
return Math.atan2(only[1] - v[1], only[0] - v[0]) + Math.PI
|
||||
}
|
||||
const ta = Math.atan2(before[1] - v[1], before[0] - v[0])
|
||||
const tb = Math.atan2(after[1] - v[1], after[0] - v[0])
|
||||
const gap = (((tb - ta) % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI)
|
||||
const bisector = ta + gap / 2
|
||||
return gap > Math.PI ? bisector : bisector + Math.PI
|
||||
}
|
||||
|
||||
function aroundVertex(scene: BubbleScene, chosen: number): Around {
|
||||
const { points, inserts, unit } = scene
|
||||
const v = points[chosen]
|
||||
const rel = (x: number, y: number): XY => ({
|
||||
x: (x - v[0]) / unit,
|
||||
y: (y - v[1]) / unit,
|
||||
})
|
||||
const insertMids = points.flatMap((p, s) => {
|
||||
if (!inserts[s]) return []
|
||||
const q = points[(s + 1) % points.length]
|
||||
return [rel((p[0] + q[0]) / 2, (p[1] + q[1]) / 2)]
|
||||
})
|
||||
const vertices = points
|
||||
.filter((p) => !samePoint(p, v))
|
||||
.map((p) => rel(p[0], p[1]))
|
||||
return { insertMids, vertices }
|
||||
}
|
||||
|
||||
/** The bound in force: `bounds`, or the whole frame when the vertex is off screen. */
|
||||
function effectiveBounds(scene: BubbleScene, vertex: Point): Frame | null {
|
||||
const { bounds, frame } = scene
|
||||
if (bounds === null) return null
|
||||
const slack = EDGE_PX * scene.unit
|
||||
const onScreen =
|
||||
vertex[0] >= bounds.x - slack &&
|
||||
vertex[0] <= bounds.x + bounds.w + slack &&
|
||||
vertex[1] >= bounds.y - slack &&
|
||||
vertex[1] <= bounds.y + bounds.h + slack
|
||||
return onScreen ? bounds : frame
|
||||
}
|
||||
|
||||
function rectInside(
|
||||
centre: XY,
|
||||
vertex: Point,
|
||||
scene: BubbleScene,
|
||||
bounds: Frame | null,
|
||||
): boolean {
|
||||
if (bounds === null) return true
|
||||
const { unit, sizes } = scene
|
||||
const cx = vertex[0] + centre.x * unit
|
||||
const cy = vertex[1] + centre.y * unit
|
||||
const hw = (sizes.bubble.w / 2) * unit
|
||||
const hh = (sizes.bubble.h / 2) * unit
|
||||
const slack = EDGE_PX * unit
|
||||
return (
|
||||
cx - hw >= bounds.x - slack &&
|
||||
cx + hw <= bounds.x + bounds.w + slack &&
|
||||
cy - hh >= bounds.y - slack &&
|
||||
cy + hh <= bounds.y + bounds.h + slack
|
||||
)
|
||||
}
|
||||
|
||||
function isUnambiguous(centre: XY, mids: XY[], sizes: HandleSizes): boolean {
|
||||
return mids.every(
|
||||
(m) =>
|
||||
(Math.abs(m.x - centre.x) > sizes.bubble.w / 2 ||
|
||||
Math.abs(m.y - centre.y) > sizes.bubble.h / 2) &&
|
||||
Math.hypot(m.x - centre.x, m.y - centre.y) > sizes.hit,
|
||||
)
|
||||
}
|
||||
|
||||
function minGap(centre: XY, others: XY[], sizes: HandleSizes): number {
|
||||
return Math.min(
|
||||
Infinity,
|
||||
...others.map((o) => bubbleClearance(centre, o, sizes)),
|
||||
)
|
||||
}
|
||||
|
||||
/** The candidate centres in px, in preference order: nearer first, then each turn. */
|
||||
function candidates(open: number, sizes: HandleSizes): XY[] {
|
||||
return FARTHER_PX.flatMap((extra) =>
|
||||
TURNS.map((turn) => {
|
||||
const theta = open + turn
|
||||
const d =
|
||||
sizes.hit +
|
||||
(sizes.bubble.w / 2) * Math.abs(Math.cos(theta)) +
|
||||
(sizes.bubble.h / 2) * Math.abs(Math.sin(theta)) +
|
||||
GAP_PX +
|
||||
extra
|
||||
return { x: d * Math.cos(theta), y: d * Math.sin(theta) }
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
function score(
|
||||
centre: XY,
|
||||
around: Around,
|
||||
inside: boolean,
|
||||
sizes: HandleSizes,
|
||||
): Scored {
|
||||
return {
|
||||
centre,
|
||||
inside,
|
||||
insertGap: minGap(centre, around.insertMids, sizes),
|
||||
vertexGap: minGap(centre, around.vertices, sizes),
|
||||
unambiguous: isUnambiguous(centre, around.insertMids, sizes),
|
||||
}
|
||||
}
|
||||
|
||||
function largestInsertGap(list: Scored[]): Scored | undefined {
|
||||
return list.reduce<Scored | undefined>(
|
||||
(best, c) =>
|
||||
best === undefined || c.insertGap > best.insertGap ? c : best,
|
||||
undefined,
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Precedence: clear of every « + » and vertex, then of every « + », then unambiguous,
|
||||
* always on screen first.
|
||||
*/
|
||||
function choose(scored: Scored[]): Scored {
|
||||
const inside = scored.filter((c) => c.inside)
|
||||
return (
|
||||
inside.find((c) => c.insertGap >= 0 && c.vertexGap >= 0) ??
|
||||
inside.find((c) => c.insertGap >= 0) ??
|
||||
largestInsertGap(inside.filter((c) => c.unambiguous)) ??
|
||||
largestInsertGap(inside) ??
|
||||
scored[0]
|
||||
)
|
||||
}
|
||||
|
||||
/** The centre of the « − » bubble of vertex `chosen`, in drawing units. */
|
||||
export function removeBubbleCentre(scene: BubbleScene, chosen: number): Point {
|
||||
const vertex = scene.points[chosen]
|
||||
const open = openDirection(scene.points, chosen)
|
||||
const around = aroundVertex(scene, chosen)
|
||||
const bounds = effectiveBounds(scene, vertex)
|
||||
const scored = candidates(open, scene.sizes).map((c) =>
|
||||
score(c, around, rectInside(c, vertex, scene, bounds), scene.sizes),
|
||||
)
|
||||
const { centre } = choose(scored)
|
||||
return [vertex[0] + centre.x * scene.unit, vertex[1] + centre.y * scene.unit]
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
/** U2 trial: placement of the « − » bubble against the real hit areas (coarse sizes). */
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { resolve } from 'node:path'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { AnatomicalSheetDocument, Point } from '@faunosteo/core-wasm/types'
|
||||
import type { Frame, XY } from '@/editor/annotations/frame'
|
||||
import { deviceSizes, type HandleSizes } from '@/editor/annotations/handleSize'
|
||||
import { showsInsert } from '@/editor/annotations/polygonEdit'
|
||||
import {
|
||||
bubbleClearance,
|
||||
removeBubbleCentre,
|
||||
visibleBounds,
|
||||
type BubbleScene,
|
||||
} from '@/editor/annotations/removeBubble'
|
||||
|
||||
const SEED = resolve(
|
||||
fileURLToPath(import.meta.url),
|
||||
'../../../../../supabase/seed/anatomical-sheets/equine/draft',
|
||||
)
|
||||
const draft = JSON.parse(
|
||||
readFileSync(resolve(SEED, 'document.json'), 'utf8'),
|
||||
) as AnatomicalSheetDocument
|
||||
const viewBox = /viewBox="([^"]+)"/.exec(
|
||||
readFileSync(resolve(SEED, 'assets/horse.svg'), 'utf8'),
|
||||
)![1]
|
||||
const [fx, fy, fw, fh] = viewBox.split(/\s+/).map(Number)
|
||||
const FRAME: Frame = { x: fx, y: fy, w: fw, h: fh }
|
||||
|
||||
const polygons = draft.annotations.flatMap((a) => {
|
||||
const g = a.geometry
|
||||
return a.view_id === 'main' && g !== null && g.type === 'polygon'
|
||||
? [{ id: a.id, points: g.points as Point[] }]
|
||||
: []
|
||||
})
|
||||
|
||||
function stubPointer(coarse: boolean) {
|
||||
vi.stubGlobal('matchMedia', (query: string) => ({
|
||||
matches: coarse,
|
||||
media: query,
|
||||
}))
|
||||
}
|
||||
beforeEach(() => stubPointer(true))
|
||||
afterEach(() => vi.unstubAllGlobals())
|
||||
|
||||
const px = (p: Point, unit: number): XY => ({ x: p[0] / unit, y: p[1] / unit })
|
||||
|
||||
function insertsFor(
|
||||
points: readonly Point[],
|
||||
unit: number,
|
||||
sizes: HandleSizes,
|
||||
): boolean[] {
|
||||
return points.map((p, s) => {
|
||||
const q = points[(s + 1) % points.length]
|
||||
return showsInsert(Math.hypot(q[0] - p[0], q[1] - p[1]) / unit, sizes.hit)
|
||||
})
|
||||
}
|
||||
|
||||
const mid = (a: Point, b: Point, unit: number): XY =>
|
||||
px([(a[0] + b[0]) / 2, (a[1] + b[1]) / 2], unit)
|
||||
|
||||
function sceneOf(
|
||||
points: readonly Point[],
|
||||
unit: number,
|
||||
sizes: HandleSizes,
|
||||
bounds: Frame | null,
|
||||
frame: Frame | null = bounds,
|
||||
): BubbleScene {
|
||||
return {
|
||||
points,
|
||||
inserts: insertsFor(points, unit, sizes),
|
||||
unit,
|
||||
sizes,
|
||||
bounds,
|
||||
frame,
|
||||
}
|
||||
}
|
||||
|
||||
const shownMids = (scene: BubbleScene): XY[] =>
|
||||
scene.points.flatMap((p, s) =>
|
||||
scene.inserts[s]
|
||||
? [mid(p, scene.points[(s + 1) % scene.points.length], scene.unit)]
|
||||
: [],
|
||||
)
|
||||
|
||||
const insideFrame = (c: XY, sizes: HandleSizes, unit: number, b: Frame) =>
|
||||
c.x * unit - (sizes.bubble.w / 2) * unit >= b.x - 1e-9 &&
|
||||
c.x * unit + (sizes.bubble.w / 2) * unit <= b.x + b.w + 1e-9 &&
|
||||
c.y * unit - (sizes.bubble.h / 2) * unit >= b.y - 1e-9 &&
|
||||
c.y * unit + (sizes.bubble.h / 2) * unit <= b.y + b.h + 1e-9
|
||||
|
||||
describe('visibleBounds', () => {
|
||||
const box = { w: 100, h: 100 }
|
||||
const frame = { x: 0, y: 0, w: 100, h: 100 }
|
||||
it('is the frame at fit', () => {
|
||||
expect(visibleBounds(frame, box, { x: 0, y: 0, scale: 1 })).toEqual(frame)
|
||||
})
|
||||
it('is the part on screen when zoomed and panned', () => {
|
||||
expect(visibleBounds(frame, box, { x: -50, y: -50, scale: 2 })).toEqual({
|
||||
x: 25,
|
||||
y: 25,
|
||||
w: 50,
|
||||
h: 50,
|
||||
})
|
||||
})
|
||||
it('is null for an empty box', () => {
|
||||
expect(
|
||||
visibleBounds(frame, { w: 0, h: 10 }, { x: 0, y: 0, scale: 1 }),
|
||||
).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('removeBubbleCentre', () => {
|
||||
it('there are six equine polygons on the main view', () => {
|
||||
expect(polygons.map((p) => p.id)).toHaveLength(6)
|
||||
})
|
||||
|
||||
it('control: the old centre fails the criterion (thoracic, vertex 2)', () => {
|
||||
const sizes = deviceSizes()
|
||||
const { points } = polygons.find((p) => p.id.includes('thoracic'))!
|
||||
const unit = 1 / ((679 / FRAME.w) * 2.25)
|
||||
const scene = sceneOf(points, unit, sizes, FRAME)
|
||||
const v = points[2]
|
||||
const old: XY = px([v[0], v[1] - (9 + 6 + 18) * unit], unit)
|
||||
const gaps = shownMids(scene).map((m) => bubbleClearance(old, m, sizes))
|
||||
expect(Math.min(...gaps)).toBeLessThan(0)
|
||||
})
|
||||
|
||||
it('sweep: clear of every shown « + » and its own vertex, inside the frame', () => {
|
||||
const sizes = deviceSizes()
|
||||
let count = 0
|
||||
for (const { points } of polygons) {
|
||||
for (const width of [621, 679, 694]) {
|
||||
for (let k = 0; k <= 100; k++) {
|
||||
const zoom = 1 + k * 0.05
|
||||
const unit =
|
||||
1 / (Math.min(width / FRAME.w, (width * 0.75) / FRAME.h) * zoom)
|
||||
const scene = sceneOf(points, unit, sizes, FRAME)
|
||||
const mids = shownMids(scene)
|
||||
points.forEach((v, i) => {
|
||||
const [bx, by] = removeBubbleCentre(scene, i)
|
||||
const c = px([bx, by], unit)
|
||||
count++
|
||||
for (const m of mids) {
|
||||
expect(bubbleClearance(c, m, sizes)).toBeGreaterThanOrEqual(0)
|
||||
expect(c).not.toEqual(m)
|
||||
}
|
||||
expect(
|
||||
bubbleClearance(c, px(v, unit), sizes),
|
||||
).toBeGreaterThanOrEqual(0)
|
||||
expect(insideFrame(c, sizes, unit, FRAME)).toBe(true)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
expect(count).toBeGreaterThan(1000)
|
||||
}, 60_000)
|
||||
|
||||
it('window: stays in the shown part, an off-screen vertex is not forced', () => {
|
||||
const sizes = fine()
|
||||
const square: Point[] = [
|
||||
[0, 0],
|
||||
[100, 0],
|
||||
[100, 100],
|
||||
[0, 100],
|
||||
]
|
||||
const window: Frame = { x: 0, y: 0, w: 60, h: 60 }
|
||||
const scene = sceneOf(square, 1, sizes, window, {
|
||||
x: 0,
|
||||
y: 0,
|
||||
w: 100,
|
||||
h: 100,
|
||||
})
|
||||
const [x0, y0] = removeBubbleCentre(scene, 0)
|
||||
expect(insideFrame({ x: x0, y: y0 }, sizes, 1, window)).toBe(true)
|
||||
const [x2, y2] = removeBubbleCentre(scene, 2)
|
||||
expect(insideFrame({ x: x2, y: y2 }, sizes, 1, window)).toBe(false)
|
||||
expect(
|
||||
insideFrame({ x: x2, y: y2 }, sizes, 1, { x: 0, y: 0, w: 100, h: 100 }),
|
||||
).toBe(true)
|
||||
})
|
||||
|
||||
it('vertex rung: keeps clear of another vertex straight ahead', () => {
|
||||
const sizes = deviceSizes()
|
||||
// vertex 0 opens up-left (towards -y); another vertex sits 40 px straight above it.
|
||||
const points: Point[] = [
|
||||
[0, 0],
|
||||
[60, 20],
|
||||
[60, 80],
|
||||
[0, 80],
|
||||
[0, -40],
|
||||
]
|
||||
const scene = sceneOf(points, 1, sizes, null)
|
||||
const [bx, by] = removeBubbleCentre(scene, 0)
|
||||
expect(
|
||||
bubbleClearance({ x: bx, y: by }, { x: 0, y: -40 }, sizes),
|
||||
).toBeGreaterThanOrEqual(0)
|
||||
expect(
|
||||
bubbleClearance({ x: bx, y: by }, { x: 0, y: 0 }, sizes),
|
||||
).toBeGreaterThanOrEqual(0)
|
||||
})
|
||||
|
||||
it('degenerate: repeated points give finite centres clear of the « + »', () => {
|
||||
const sizes = fine()
|
||||
const points: Point[] = [
|
||||
[10, 10],
|
||||
[10, 10],
|
||||
[60, 10],
|
||||
[60, 60],
|
||||
]
|
||||
const scene = sceneOf(points, 1, sizes, { x: 0, y: 0, w: 100, h: 100 })
|
||||
const mids = shownMids(scene)
|
||||
points.forEach((_, i) => {
|
||||
const [bx, by] = removeBubbleCentre(scene, i)
|
||||
expect(Number.isFinite(bx) && Number.isFinite(by)).toBe(true)
|
||||
for (const m of mids) {
|
||||
expect(
|
||||
bubbleClearance({ x: bx, y: by }, m, sizes),
|
||||
).toBeGreaterThanOrEqual(0)
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
function fine(): HandleSizes {
|
||||
stubPointer(false)
|
||||
const sizes = deviceSizes()
|
||||
stubPointer(true)
|
||||
return sizes
|
||||
}
|
||||
|
||||
describe('panned sweep (vertex at a chosen screen spot while zoomed)', () => {
|
||||
it('stays on screen and unambiguous but for a few window corners', () => {
|
||||
const sizes = deviceSizes()
|
||||
const W = 679
|
||||
const H = W * 0.75
|
||||
const base = Math.min(W / FRAME.w, H / FRAME.h)
|
||||
const ox = (W - FRAME.w * base) / 2
|
||||
const oy = (H - FRAME.h * base) / 2
|
||||
const xs = [0, 20, 60, W / 2, W - 60, W - 20, W]
|
||||
const ys = [0, 20, 60, H / 2, H - 60, H - 20, H]
|
||||
const exceptions: string[] = []
|
||||
const offscreen: string[] = []
|
||||
let clear = 0
|
||||
let total = 0
|
||||
for (const { id, points } of polygons) {
|
||||
for (const zoom of [2.25, 3.375, 5.0625]) {
|
||||
const unit = 1 / (base * zoom)
|
||||
points.forEach((v, i) => {
|
||||
for (const sx of xs)
|
||||
for (const sy of ys) {
|
||||
const p = {
|
||||
x: ox + (v[0] - FRAME.x) * base,
|
||||
y: oy + (v[1] - FRAME.y) * base,
|
||||
}
|
||||
const framing = {
|
||||
x: sx - zoom * p.x,
|
||||
y: sy - zoom * p.y,
|
||||
scale: zoom,
|
||||
}
|
||||
const bounds = visibleBounds(FRAME, { w: W, h: H }, framing)
|
||||
const scene = sceneOf(points, unit, sizes, bounds, FRAME)
|
||||
const [bx, by] = removeBubbleCentre(scene, i)
|
||||
const c = px([bx, by], unit)
|
||||
const where = `${id} v${i} z${zoom} at (${sx}, ${sy})`
|
||||
total++
|
||||
const mids = shownMids(scene)
|
||||
if (!insideFrame(c, sizes, unit, bounds!)) offscreen.push(where)
|
||||
const ambiguous = mids.some(
|
||||
(m) =>
|
||||
(Math.abs(m.x - c.x) <= sizes.bubble.w / 2 &&
|
||||
Math.abs(m.y - c.y) <= sizes.bubble.h / 2) ||
|
||||
Math.hypot(m.x - c.x, m.y - c.y) <= sizes.hit,
|
||||
)
|
||||
if (ambiguous) exceptions.push(where)
|
||||
if (mids.every((m) => bubbleClearance(c, m, sizes) >= 0)) clear++
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
console.info(`panned: ${total} placements, ${clear} meet (a)`)
|
||||
console.info(`ambiguous: ${exceptions.join(' | ')}`)
|
||||
console.info(`off screen: ${offscreen.length}`)
|
||||
expect(offscreen).toEqual([])
|
||||
expect(exceptions.length).toBeLessThanOrEqual(3)
|
||||
}, 60_000)
|
||||
})
|
||||
Reference in new issue
Block a user