स्केच सॉल्वर

सॉल्वर क्या करता है

स्केच सॉल्वर बिंदुओं, रेखाओं, वृत्तों और चापों के साथ-साथ ज्यामितीय और आयामी बाधाओं के एक सेट को ठोस निर्देशांक में बदल देता है। वो में रहता है packages/core/src/cad/sketch.ts (522 लाइनें) और से निर्यात किया जाता है @cadcamfun/core के रूप में solveSketch, sketchProfiles और polygonArea. पैरामीट्रिक इतिहास पहले अपनी अभिव्यक्तियों को संख्याओं में हल करता है, फिर सॉल्वर को कॉल करता है; हल की गई प्रोफाइल एक्सट्रूड्स, रिवॉल्व्स और पॉकेट्स को फीड करती है।

डेटा मॉडल

बिंदु अज्ञात हैं. प्रत्येक रेखा, वृत्त और चाप आईडी के आधार पर बिंदुओं को संदर्भित करते हैं, इसलिए दो रेखाएं जो एक छोर साझा करती हैं, बिंदु साझा करती हैं और एक साथ चलती हैं। एक वृत्त एक और अज्ञात, उसकी त्रिज्या जोड़ता है। एक चाप एक केंद्र होता है और वृत्त पर वामावर्त दिशा में दो बिंदु होते हैं start तक end; इसकी त्रिज्या |प्रारंभ − केंद्र| और सॉल्वर अपना समीकरण रखते हुए जोड़ता है end एक ही घेरे पर.

export interface SketchPoint  { id: string; kind: "point";  x: number; y: number }
export interface SketchLine   { id: string; kind: "line";   p1: PointId; p2: PointId }
export interface SketchCircle { id: string; kind: "circle"; center: PointId; radius: number }
/** Counter-clockwise from `start` to `end` about `center`. */
export interface SketchArc    { id: string; kind: "arc";    center: PointId; start: PointId; end: PointId }

export interface Sketch {
  readonly entities: ReadonlyArray<SketchEntity>
  readonly constraints: ReadonlyArray<Constraint>
}

अज्ञात वेक्टर को प्रत्येक बिंदु के रूप में रखा गया है x, y इकाई क्रम में, फिर प्रत्येक सर्कल में r. चार बिंदुओं वाले एक आयत में 8 अज्ञात हैं; अपने स्वयं के केंद्र के साथ एक वृत्त जोड़ें और इसमें 11 है।

बाधा सूची

प्रत्येक बाधा अवशिष्ट समीकरणों का योगदान करती है जो धारण करने पर शून्य होते हैं। एक बाधा एक ले जा सकती है id; बिना किसी के इसका नाम रखा गया है type#index (उदाहरण के लिए vertical#2) संघर्ष रिपोर्टों में।

समाधान: लेवेनबर्ग-मार्क्वार्ट

सॉल्वर लेवेनबर्ग-मार्क्वार्ड और एक केंद्रीय-अंतर जैकोबियन के साथ वर्ग अवशेषों के योग को कम करता है। प्रत्येक चरण चोलेस्की गुणनखंडन द्वारा अवमंदित सामान्य समीकरणों को हल करता है; एक कदम जो अवशिष्ट को कम करता है उसे स्वीकार कर लिया जाता है और अवमंदन कम हो जाता है, एक ऐसा कदम जो अवशिष्ट को कम नहीं करता है उसे अस्वीकार कर दिया जाता है और अवमंदन बढ़ता है। क्योंकि प्रत्येक चरण सबसे छोटा परिवर्तन है जो अवशेषों को कम करता है, एक खींचा हुआ बिंदु शेष स्केच को उसी तरह खींचता है जैसे वह एक ड्राइंग बोर्ड पर होता है।

1. प्रत्येक बाधा के अवशिष्ट फ़ंक्शन का निर्माण करें, और रिकॉर्ड करें कि कौन सी बाधा प्रत्येक समीकरण का स्वामी है।
2. Start with λ = 1e-3. Solve (JᵀJ + λ·max(1, diag)) Δx = −Jᵀr; if Cholesky fails, multiply λ by 10 and retry.
3. Accept the step if the residual norm drops (λ = max(λ/5, 1e-12)); otherwise λ ×= 10.
4. जब अवशेष नीचे हो तो रुकें tolerance (1ई-9) या उसके बाद maxIterations (200).
5. Analyse the Jacobian at the solution: rank by Gaussian elimination with full pivoting (tolerance 1e-7), null-space basis, free unknowns (component above 1e-6).

स्थिति एवं निदान

हल करने के बाद, स्वतंत्रता की डिग्री = अज्ञात - रैंक और अनावश्यक समीकरण = समीकरण - रैंक। स्थिति उन दो संख्याओं से और क्या अवशेष 1e-6 तक पहुंच गया है, से पता चलता है।

These results come from running the solver on a rectangle drawn slightly askew: a(0,0) b(38,2) c(41,27) d(−1,24), with a fixed at the origin and the four lines horizontal/vertical.

// + length(l1) = 40
{"status":"under-constrained","dof":1,"free":["c","d"],"iterations":3,"redundant":0}
// + length(l2) = 25
{"status":"fully-constrained","dof":0,"iterations":3,"residual":7.95e-12,
 "points":[["a",0,0],["b",40,0],["c",40,25],["d",0,25]]}
// + length(l3) = 40   (implied by the others)
{"status":"over-constrained","dof":0,"redundant":1}
// + length(l3) = 30   named "bad"
{"status":"conflicting","redundant":1,
 "conflicts":["bad","vertical#2","length#5","vertical#4"],
 "message":"The constraints cannot all hold; the worst miss is bad"}

API

export const solveSketch: (sketch: Sketch, options?: SolveOptions) => SolveResult
export const sketchProfiles: (sketch: Sketch, tolerance?: number /* 0.01 */) =>
  { readonly loops: Vec2[][]; readonly open: Vec2[][] }
export const polygonArea: (ring: ReadonlyArray<Vec2>) => number   // positive counter-clockwise
export class SketchError extends Error {}

export interface SolveResult {
  sketch: Sketch; status: SolveStatus; dof: number; iterations: number
  residual: number          // largest absolute residual left
  free: string[]            // points and circles that can still move
  conflicts: string[]       // worst first, only when not solved
  redundant: number
  message?: string
}

import { solveSketch, sketchProfiles, polygonArea } from "@cadcamfun/core"

const P = (id: string, x: number, y: number) => ({ id, kind: "point" as const, x, y })
const L = (id: string, p1: string, p2: string) => ({ id, kind: "line" as const, p1, p2 })

const result = solveSketch({
  entities: [P("a", 0, 0), P("b", 38, 2), P("c", 41, 27), P("d", -1, 24),
    L("l1", "a", "b"), L("l2", "b", "c"), L("l3", "c", "d"), L("l4", "d", "a"),
    P("o", 20, 12), { id: "h", kind: "circle", center: "o", radius: 4 }],
  constraints: [
    { type: "fixed", point: "a", x: 0, y: 0 },
    { type: "horizontal", line: "l1" }, { type: "vertical", line: "l2" },
    { type: "horizontal", line: "l3" }, { type: "vertical", line: "l4" },
    { type: "length", line: "l1", value: 40 }, { type: "length", line: "l2", value: 25 },
    { type: "distanceX", a: "a", b: "o", value: 20 }, { type: "distanceY", a: "a", b: "o", value: 12.5 },
    { type: "diameter", circle: "h", value: 10 },
  ],
})
result.status                       // "fully-constrained", dof 0
const { loops } = sketchProfiles(result.sketch)
loops.map((l) => [l.length, polygonArea(l)])
// [[50, 78.333], [4, 1000]]   circle: 50 points; rectangle: 4 points, area 1000

स्केच से लेकर प्रोफाइल तक

उपरोक्त स्लॉट को इस प्रकार हल किया गया over-constrained dof 0 और 1 निरर्थक समीकरण के साथ: बनाना top क्षैतिज का तात्पर्य तब होता है जब c1-a1 और c2-b1 ऊर्ध्वाधर होते हैं और c1, c2 एक y साझा करते हैं। समाधान अभी भी सफल होता है; स्थिति केवल डुप्लिकेट को चिह्नित करती है।

समस्या निवारण