P5: add facade sketch model solver and persistence
This commit is contained in:
222
src/facade/sketcher.ts
Normal file
222
src/facade/sketcher.ts
Normal file
@@ -0,0 +1,222 @@
|
||||
export type SketchPoint = { x: number; y: number }
|
||||
|
||||
export type SketchGeometry =
|
||||
| { id: string; type: 'point'; position: SketchPoint; construction?: boolean }
|
||||
| { id: string; type: 'line'; start: SketchPoint; end: SketchPoint; construction?: boolean }
|
||||
| { id: string; type: 'circle'; center: SketchPoint; radius: number; construction?: boolean }
|
||||
| { id: string; type: 'arc'; center: SketchPoint; radius: number; startAngle: number; endAngle: number; construction?: boolean }
|
||||
|
||||
export type SketchPointRef = { geometryId: string; point: 'start' | 'end' | 'center' }
|
||||
|
||||
export type SketchConstraint =
|
||||
| { id: string; type: 'coincident'; first: SketchPointRef; second: SketchPointRef; driving?: boolean }
|
||||
| { id: string; type: 'horizontal' | 'vertical'; geometryId: string; driving?: boolean }
|
||||
| { id: string; type: 'distance' | 'distanceX' | 'distanceY'; first: SketchPointRef; second: SketchPointRef; value: number; driving?: boolean }
|
||||
| { id: string; type: 'radius'; geometryId: string; value: number; driving?: boolean }
|
||||
| { id: string; type: 'angle'; geometryId: string; value: number; driving?: boolean }
|
||||
| { id: string; type: 'equal'; firstGeometryId: string; secondGeometryId: string; driving?: boolean }
|
||||
| { id: string; type: 'block'; geometryId: string; driving?: boolean }
|
||||
|
||||
export type SketchSolverStatus = 'solved' | 'under-constrained' | 'conflicting' | 'invalid'
|
||||
|
||||
export type SketchDiagnostic = {
|
||||
code: 'UNKNOWN_GEOMETRY' | 'UNKNOWN_POINT' | 'INVALID_VALUE' | 'CONSTRAINT_CONFLICT' | 'SOLVER_NOT_CONVERGED'
|
||||
constraintId?: string
|
||||
message: string
|
||||
}
|
||||
|
||||
export type SketchSnapshot = {
|
||||
id: string
|
||||
geometry: SketchGeometry[]
|
||||
constraints: SketchConstraint[]
|
||||
solver: {
|
||||
status: SketchSolverStatus
|
||||
degreesOfFreedom: number
|
||||
residual: number
|
||||
iterations: number
|
||||
diagnostics: SketchDiagnostic[]
|
||||
}
|
||||
}
|
||||
|
||||
export type SketchSolveOptions = {
|
||||
tolerance?: number
|
||||
maxIterations?: number
|
||||
}
|
||||
|
||||
export type SketchSolveResult = {
|
||||
snapshot: SketchSnapshot
|
||||
status: SketchSolverStatus
|
||||
degreesOfFreedom: number
|
||||
residual: number
|
||||
iterations: number
|
||||
diagnostics: SketchDiagnostic[]
|
||||
}
|
||||
|
||||
const cloneGeometry = (geometry: SketchGeometry): SketchGeometry => {
|
||||
if (geometry.type === 'line') return { ...geometry, start: { ...geometry.start }, end: { ...geometry.end } }
|
||||
if (geometry.type === 'circle') return { ...geometry, center: { ...geometry.center } }
|
||||
if (geometry.type === 'arc') return { ...geometry, center: { ...geometry.center } }
|
||||
return { ...geometry, position: { ...geometry.position } }
|
||||
}
|
||||
|
||||
export const cloneSketch = (sketch: SketchSnapshot): SketchSnapshot => ({
|
||||
...sketch,
|
||||
geometry: sketch.geometry.map(cloneGeometry),
|
||||
constraints: sketch.constraints.map((constraint) => ({ ...constraint })),
|
||||
solver: { ...sketch.solver, diagnostics: sketch.solver.diagnostics.map((diagnostic) => ({ ...diagnostic })) },
|
||||
})
|
||||
|
||||
export const createSketch = (id: string, geometry: SketchGeometry[] = [], constraints: SketchConstraint[] = []): SketchSnapshot => ({
|
||||
id,
|
||||
geometry: geometry.map(cloneGeometry),
|
||||
constraints: constraints.map((constraint) => ({ ...constraint })),
|
||||
solver: { status: geometry.length === 0 ? 'solved' : 'under-constrained', degreesOfFreedom: 0, residual: 0, iterations: 0, diagnostics: [] },
|
||||
})
|
||||
|
||||
const findGeometry = (geometry: SketchGeometry[], id: string, constraintId: string, diagnostics: SketchDiagnostic[]) => {
|
||||
const result = geometry.find((candidate) => candidate.id === id)
|
||||
if (!result) diagnostics.push({ code: 'UNKNOWN_GEOMETRY', constraintId, message: `Sketch geometry '${id}' does not exist.` })
|
||||
return result
|
||||
}
|
||||
|
||||
const pointFor = (geometry: SketchGeometry, point: SketchPointRef['point'], constraintId: string, diagnostics: SketchDiagnostic[]): SketchPoint | null => {
|
||||
if (geometry.type === 'point') return geometry.position
|
||||
if (geometry.type === 'line' && (point === 'start' || point === 'end')) return point === 'start' ? geometry.start : geometry.end
|
||||
if ((geometry.type === 'circle' || geometry.type === 'arc') && point === 'center') return geometry.center
|
||||
diagnostics.push({ code: 'UNKNOWN_POINT', constraintId, message: `Point '${point}' is not valid for ${geometry.type} '${geometry.id}'.` })
|
||||
return null
|
||||
}
|
||||
|
||||
const pointKey = (ref: SketchPointRef) => `${ref.geometryId}.${ref.point}`
|
||||
const distance = (left: SketchPoint, right: SketchPoint) => Math.hypot(left.x - right.x, left.y - right.y)
|
||||
const lineLength = (geometry: SketchGeometry) => geometry.type === 'line' ? distance(geometry.start, geometry.end) : geometry.type === 'circle' || geometry.type === 'arc' ? geometry.radius : 0
|
||||
|
||||
const isBlocked = (geometryId: string, blocked: Set<string>) => blocked.has(geometryId)
|
||||
|
||||
const adjustPoint = (geometry: SketchGeometry, point: SketchPointRef['point'], next: SketchPoint, blocked: Set<string>) => {
|
||||
if (isBlocked(geometry.id, blocked)) return
|
||||
if (geometry.type === 'point') { geometry.position = { ...next }; return }
|
||||
if (geometry.type === 'line') { if (point === 'start') geometry.start = { ...next }; else if (point === 'end') geometry.end = { ...next }; return }
|
||||
if (point === 'center') geometry.center = { ...next }
|
||||
}
|
||||
|
||||
const validateConstraintValues = (constraint: SketchConstraint, diagnostics: SketchDiagnostic[]) => {
|
||||
if ('value' in constraint && (!Number.isFinite(constraint.value) || constraint.value < 0)) diagnostics.push({ code: 'INVALID_VALUE', constraintId: constraint.id, message: `Constraint '${constraint.id}' requires a finite non-negative value.` })
|
||||
}
|
||||
|
||||
const residualFor = (constraint: SketchConstraint, geometry: SketchGeometry[], diagnostics: SketchDiagnostic[]): number => {
|
||||
if (constraint.type === 'horizontal' || constraint.type === 'vertical') {
|
||||
const candidate = findGeometry(geometry, constraint.geometryId, constraint.id, diagnostics)
|
||||
if (!candidate || candidate.type !== 'line') return Infinity
|
||||
return constraint.type === 'horizontal' ? Math.abs(candidate.start.y - candidate.end.y) : Math.abs(candidate.start.x - candidate.end.x)
|
||||
}
|
||||
if (constraint.type === 'radius') {
|
||||
const candidate = findGeometry(geometry, constraint.geometryId, constraint.id, diagnostics)
|
||||
return candidate && (candidate.type === 'circle' || candidate.type === 'arc') ? Math.abs(candidate.radius - constraint.value) : Infinity
|
||||
}
|
||||
if (constraint.type === 'angle') {
|
||||
const candidate = findGeometry(geometry, constraint.geometryId, constraint.id, diagnostics)
|
||||
if (!candidate || candidate.type !== 'line') return Infinity
|
||||
return Math.abs(Math.atan2(candidate.end.y - candidate.start.y, candidate.end.x - candidate.start.x) - constraint.value)
|
||||
}
|
||||
if (constraint.type === 'equal') {
|
||||
const first = findGeometry(geometry, constraint.firstGeometryId, constraint.id, diagnostics)
|
||||
const second = findGeometry(geometry, constraint.secondGeometryId, constraint.id, diagnostics)
|
||||
return first && second ? Math.abs(lineLength(first) - lineLength(second)) : Infinity
|
||||
}
|
||||
if (constraint.type === 'block') return 0
|
||||
if (constraint.type !== 'coincident' && constraint.type !== 'distance' && constraint.type !== 'distanceX' && constraint.type !== 'distanceY') return Infinity
|
||||
const firstGeometry = findGeometry(geometry, constraint.first.geometryId, constraint.id, diagnostics)
|
||||
const secondGeometry = findGeometry(geometry, constraint.second.geometryId, constraint.id, diagnostics)
|
||||
if (!firstGeometry || !secondGeometry) return Infinity
|
||||
const first = pointFor(firstGeometry, constraint.first.point, constraint.id, diagnostics)
|
||||
const second = pointFor(secondGeometry, constraint.second.point, constraint.id, diagnostics)
|
||||
if (!first || !second) return Infinity
|
||||
if (constraint.type === 'coincident') return distance(first, second)
|
||||
if (constraint.type === 'distance') return Math.abs(distance(first, second) - constraint.value)
|
||||
if (constraint.type === 'distanceX') return Math.abs(Math.abs(second.x - first.x) - constraint.value)
|
||||
return Math.abs(Math.abs(second.y - first.y) - constraint.value)
|
||||
}
|
||||
|
||||
export const solveSketch = (input: SketchSnapshot, options: SketchSolveOptions = {}): SketchSolveResult => {
|
||||
const tolerance = options.tolerance ?? 1e-7
|
||||
const maxIterations = options.maxIterations ?? 64
|
||||
const snapshot = cloneSketch(input)
|
||||
const diagnostics: SketchDiagnostic[] = []
|
||||
const geometryById = new Map(snapshot.geometry.map((geometry) => [geometry.id, geometry]))
|
||||
const blocked = new Set(snapshot.constraints.filter((constraint) => constraint.type === 'block').map((constraint) => constraint.geometryId))
|
||||
snapshot.constraints.forEach((constraint) => validateConstraintValues(constraint, diagnostics))
|
||||
let residual = Infinity
|
||||
let iterations = 0
|
||||
for (; iterations < maxIterations && residual > tolerance && diagnostics.length === 0; iterations += 1) {
|
||||
for (const constraint of snapshot.constraints) {
|
||||
if (constraint.type === 'block') continue
|
||||
if (constraint.type === 'horizontal' || constraint.type === 'vertical') {
|
||||
const candidate = geometryById.get(constraint.geometryId)
|
||||
if (!candidate || candidate.type !== 'line') { findGeometry(snapshot.geometry, constraint.geometryId, constraint.id, diagnostics); continue }
|
||||
if (!isBlocked(candidate.id, blocked)) {
|
||||
if (constraint.type === 'horizontal') candidate.end = { ...candidate.end, y: candidate.start.y }
|
||||
else candidate.end = { ...candidate.end, x: candidate.start.x }
|
||||
}
|
||||
} else if (constraint.type === 'radius') {
|
||||
const candidate = geometryById.get(constraint.geometryId)
|
||||
if (!candidate || (candidate.type !== 'circle' && candidate.type !== 'arc')) { findGeometry(snapshot.geometry, constraint.geometryId, constraint.id, diagnostics); continue }
|
||||
if (!isBlocked(candidate.id, blocked)) candidate.radius = constraint.value
|
||||
} else if (constraint.type === 'coincident' || constraint.type === 'distance' || constraint.type === 'distanceX' || constraint.type === 'distanceY') {
|
||||
const firstGeometry = geometryById.get(constraint.first.geometryId)
|
||||
const secondGeometry = geometryById.get(constraint.second.geometryId)
|
||||
if (!firstGeometry || !secondGeometry) { findGeometry(snapshot.geometry, !firstGeometry ? constraint.first.geometryId : constraint.second.geometryId, constraint.id, diagnostics); continue }
|
||||
const first = pointFor(firstGeometry, constraint.first.point, constraint.id, diagnostics)
|
||||
const second = pointFor(secondGeometry, constraint.second.point, constraint.id, diagnostics)
|
||||
if (!first || !second) continue
|
||||
const firstBlocked = isBlocked(firstGeometry.id, blocked)
|
||||
const secondBlocked = isBlocked(secondGeometry.id, blocked)
|
||||
if (constraint.type === 'coincident') {
|
||||
if (!firstBlocked && !secondBlocked) { const midpoint = { x: (first.x + second.x) / 2, y: (first.y + second.y) / 2 }; adjustPoint(firstGeometry, constraint.first.point, midpoint, blocked); adjustPoint(secondGeometry, constraint.second.point, midpoint, blocked) }
|
||||
else if (!firstBlocked) adjustPoint(firstGeometry, constraint.first.point, second, blocked)
|
||||
else if (!secondBlocked) adjustPoint(secondGeometry, constraint.second.point, first, blocked)
|
||||
} else {
|
||||
const dx = second.x - first.x
|
||||
const dy = second.y - first.y
|
||||
const current = constraint.type === 'distance' ? Math.hypot(dx, dy) : constraint.type === 'distanceX' ? Math.abs(dx) : Math.abs(dy)
|
||||
const delta = constraint.value - current
|
||||
if (Math.abs(delta) > tolerance && !secondBlocked) {
|
||||
if (constraint.type === 'distance') {
|
||||
const length = Math.hypot(dx, dy) || 1
|
||||
adjustPoint(secondGeometry, constraint.second.point, { x: second.x + dx / length * delta, y: second.y + dy / length * delta }, blocked)
|
||||
} else if (constraint.type === 'distanceX') adjustPoint(secondGeometry, constraint.second.point, { x: first.x + (dx < 0 ? -constraint.value : constraint.value), y: second.y }, blocked)
|
||||
else adjustPoint(secondGeometry, constraint.second.point, { x: second.x, y: first.y + (dy < 0 ? -constraint.value : constraint.value) }, blocked)
|
||||
}
|
||||
}
|
||||
} else if (constraint.type === 'equal') {
|
||||
const first = geometryById.get(constraint.firstGeometryId)
|
||||
const second = geometryById.get(constraint.secondGeometryId)
|
||||
if (!first || !second) { findGeometry(snapshot.geometry, !first ? constraint.firstGeometryId : constraint.secondGeometryId, constraint.id, diagnostics); continue }
|
||||
if (!isBlocked(second.id, blocked)) {
|
||||
if ((second.type === 'circle' || second.type === 'arc') && (first.type === 'circle' || first.type === 'arc')) second.radius = first.radius
|
||||
else if (second.type === 'line' && first.type === 'line') { const current = lineLength(second) || 1; const target = lineLength(first); const scale = target / current; second.end = { x: second.start.x + (second.end.x - second.start.x) * scale, y: second.start.y + (second.end.y - second.start.y) * scale } }
|
||||
}
|
||||
} else if (constraint.type === 'angle') {
|
||||
const candidate = geometryById.get(constraint.geometryId)
|
||||
if (!candidate || candidate.type !== 'line') { findGeometry(snapshot.geometry, constraint.geometryId, constraint.id, diagnostics); continue }
|
||||
if (!isBlocked(candidate.id, blocked)) { const length = lineLength(candidate); candidate.end = { x: candidate.start.x + Math.cos(constraint.value) * length, y: candidate.start.y + Math.sin(constraint.value) * length } }
|
||||
}
|
||||
}
|
||||
residual = Math.max(0, ...snapshot.constraints.map((constraint) => residualFor(constraint, snapshot.geometry, diagnostics)))
|
||||
}
|
||||
const variableCount = snapshot.geometry.reduce((count, geometry) => count + (geometry.type === 'point' ? 2 : geometry.type === 'line' ? 4 : geometry.type === 'circle' ? 3 : 5), 0)
|
||||
const rank = Math.min(variableCount, snapshot.constraints.filter((constraint) => constraint.type !== 'block' || !isBlocked(constraint.geometryId, blocked)).length + blocked.size * 2)
|
||||
const degreesOfFreedom = Math.max(0, variableCount - rank)
|
||||
const status: SketchSolverStatus = diagnostics.length > 0 ? 'invalid' : residual <= tolerance ? degreesOfFreedom === 0 ? 'solved' : 'under-constrained' : 'conflicting'
|
||||
if (status === 'conflicting') diagnostics.push({ code: 'SOLVER_NOT_CONVERGED', message: `Sketch solver residual ${residual} exceeded tolerance ${tolerance}.` })
|
||||
snapshot.solver = { status, degreesOfFreedom, residual, iterations, diagnostics }
|
||||
return { snapshot, status, degreesOfFreedom, residual, iterations, diagnostics }
|
||||
}
|
||||
|
||||
export interface SketchSolverAdapter {
|
||||
solve(snapshot: SketchSnapshot, options?: SketchSolveOptions): Promise<SketchSolveResult>
|
||||
}
|
||||
|
||||
export class BasicSketchSolverAdapter implements SketchSolverAdapter {
|
||||
solve(snapshot: SketchSnapshot, options?: SketchSolveOptions) { return Promise.resolve(solveSketch(snapshot, options)) }
|
||||
}
|
||||
Reference in New Issue
Block a user