dsh-cad 0.2.0

package/lib/modeling/drawing.js

@@ -0,0 +1,324 @@
+/** Landscape paper in mm. */
+const PAPER = {
+    A4: { width: 297, height: 210 },
+    A3: { width: 420, height: 297 },
+};
+const FRAME = 10; // inner frame inset from the paper edge
+const GAP = 22; // breathing room between views
+const TITLE_BLOCK = { width: 130, height: 28 };
+/** GB-preferred scale series (values < 1 reduce, > 1 enlarge). */
+const SCALE_SERIES = [5, 2, 1, 0.5, 0.4, 0.25, 0.2, 0.1, 0.05, 0.02, 0.01];
+const COLORS = {
+    visible: 0x1a1d21,
+    hidden: 0x98a0ab,
+    dim: 0x2456a8,
+    paper: 0xb6bdc7,
+    text: 0x3d434c,
+};
+/** (x, y) bounds of a view's projected polylines; null when empty. */
+function viewBounds(view) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const polyline of [...view.visible, ...view.hidden]) {
+        for (let i = 0; i + 1 < polyline.length; i += 2) {
+            if (polyline[i] < minX)
+                minX = polyline[i];
+            if (polyline[i] > maxX)
+                maxX = polyline[i];
+            if (polyline[i + 1] < minY)
+                minY = polyline[i + 1];
+            if (polyline[i + 1] > maxY)
+                maxY = polyline[i + 1];
+        }
+    }
+    return Number.isFinite(minX) ? { minX, minY, maxX, maxY } : null;
+}
+function sizeOf(bounds) {
+    return bounds === null ? { w: 0, h: 0 } : { w: bounds.maxX - bounds.minX, h: bounds.maxY - bounds.minY };
+}
+/** Largest GB scale that keeps `size` inside `cell`. */
+function fitScale(viewW, viewH, cellW, cellH) {
+    if (viewW <= 1e-9 || viewH <= 1e-9)
+        return 1;
+    const raw = Math.min(cellW / viewW, cellH / viewH);
+    for (const scale of SCALE_SERIES) {
+        if (scale <= raw)
+            return scale;
+    }
+    return SCALE_SERIES[SCALE_SERIES.length - 1] ?? 0.01;
+}
+/** Scale a view's projected polylines (layout works in paper mm). */
+function scaleView(view, s) {
+    if (s === 1)
+        return view;
+    const scalePoly = (polyline) => polyline.map((v) => v * s);
+    return { name: view.name, visible: view.visible.map(scalePoly), hidden: view.hidden.map(scalePoly) };
+}
+/** Translation that centers a (scaled) view on (ox, oy). */
+function centerTransform(view, ox, oy) {
+    const bounds = viewBounds(view);
+    if (bounds === null)
+        return { tx: ox, ty: oy };
+    return { tx: ox - (bounds.minX + bounds.maxX) / 2, ty: oy - (bounds.minY + bounds.maxY) / 2 };
+}
+function trim(value) {
+    return Number(value.toFixed(1)).toString();
+}
+function scaleText(scale) {
+    return scale >= 1 ? `${trim(scale)}:1` : `1:${trim(1 / scale)}`;
+}
+/**
+ * A linear dimension: extension lines from the measure points, a dimension
+ * line offset perpendicular by `offset`, arrowhead strokes, and the measured
+ * text centered above the dimension line. `normal` is the side the dimension
+ * line sits on (unit vector).
+ */
+function linearDim(entities, p1, p2, normal, offset, text) {
+    const dx = p2[0] - p1[0];
+    const dy = p2[1] - p1[1];
+    const len = Math.hypot(dx, dy);
+    if (len < 1e-9)
+        return;
+    const ux = dx / len;
+    const uy = dy / len;
+    const [nx, ny] = normal;
+    const a1 = [p1[0] + nx * offset, p1[1] + ny * offset];
+    const a2 = [p2[0] + nx * offset, p2[1] + ny * offset];
+    const gap = 1.2;
+    const over = 2.5;
+    const extension = (p) => {
+        entities.push({
+            type: 'line',
+            x1: p[0] + nx * gap, y1: p[1] + ny * gap,
+            x2: p[0] + nx * (offset + over), y2: p[1] + ny * (offset + over),
+            layer: 'dim', color: COLORS.dim,
+        });
+    };
+    extension(p1);
+    extension(p2);
+    entities.push({ type: 'line', x1: a1[0], y1: a1[1], x2: a2[0], y2: a2[1], layer: 'dim', color: COLORS.dim });
+    // arrowheads: two strokes each, ~30° half angle, 3mm
+    for (const [at, sign] of [[a1, 1], [a2, -1]]) {
+        for (const side of [1, -1]) {
+            entities.push({
+                type: 'line',
+                x1: at[0], y1: at[1],
+                x2: at[0] + (ux * 0.87 + -uy * side * 0.5) * 3 * sign,
+                y2: at[1] + (uy * 0.87 + ux * side * 0.5) * 3 * sign,
+                layer: 'dim', color: COLORS.dim,
+            });
+        }
+    }
+    const mid = [(a1[0] + a2[0]) / 2 + nx * 1.6, (a1[1] + a2[1]) / 2 + ny * 1.6];
+    let rotation = (Math.atan2(uy, ux) * 180) / Math.PI;
+    if (rotation > 90 || rotation < -90)
+        rotation += 180;
+    entities.push({ type: 'text', x: mid[0], y: mid[1], text, height: 3.2, rotation, layer: 'dim', color: COLORS.dim });
+}
+/** Build the full drawing sheet (frame, title block, views, dimensions). */
+export function buildDrawingSheet(input) {
+    const paper = PAPER[input.paper ?? 'A4'];
+    const { width, height } = paper;
+    const byName = new Map(input.views.map((view) => [view.name, view]));
+    const front = byName.get('front');
+    const top = byName.get('top');
+    const left = byName.get('left');
+    const iso = byName.get('iso');
+    // ── placements (dimensions collected into a side list, appended later) ────
+    const placed = [];
+    const dimEntities = [];
+    let scale = 1;
+    if (front !== undefined) {
+        const regionW = (width - FRAME * 2) * 0.64;
+        const regionH = height - FRAME * 2;
+        const cellW = (regionW - GAP) / 2;
+        const cellH = (regionH - GAP) / 2;
+        const pad = 20; // room for the dimension annotations inside each cell
+        const frontSize = sizeOf(viewBounds(front));
+        const leftSize = left !== undefined ? sizeOf(viewBounds(left)) : { w: 0, h: 0 };
+        const topSize = top !== undefined ? sizeOf(viewBounds(top)) : { w: 0, h: 0 };
+        const candidates = [fitScale(frontSize.w, frontSize.h, cellW - pad, cellH - pad)];
+        if (left !== undefined)
+            candidates.push(fitScale(leftSize.w, leftSize.h, cellW - pad, cellH - pad));
+        if (top !== undefined)
+            candidates.push(fitScale(topSize.w, topSize.h, cellW - pad, cellH - pad));
+        scale = Math.min(...candidates);
+        // GB first angle: 主视图 upper-left, 左视图 right of it, 俯视图 below it.
+        const rowY = FRAME + regionH - cellH / 2;
+        const frontCX = FRAME + cellW / 2 + 4;
+        const place = (raw, ox, oy) => {
+            const scaled = scaleView(raw, scale);
+            const { tx, ty } = centerTransform(scaled, ox, oy);
+            placed.push({ view: scaled, tx, ty });
+        };
+        place(front, frontCX, rowY);
+        if (left !== undefined)
+            place(left, FRAME + cellW * 1.5 + GAP, rowY);
+        if (top !== undefined)
+            place(top, frontCX, FRAME + cellH / 2);
+        // Overall dimensions off the scaled front/top geometry (mm on paper).
+        const fw = frontSize.w * scale;
+        const fh = frontSize.h * scale;
+        if (fw > 1e-9) {
+            linearDim(dimEntities, [frontCX - fw / 2, rowY - fh / 2], [frontCX + fw / 2, rowY - fh / 2], [0, -1], 9, trim(frontSize.w));
+        }
+        if (fh > 1e-9) {
+            linearDim(dimEntities, [frontCX - fw / 2, rowY - fh / 2], [frontCX - fw / 2, rowY + fh / 2], [-1, 0], 9, trim(frontSize.h));
+        }
+        if (top !== undefined && topSize.h > 1e-9) {
+            const topCY = FRAME + cellH / 2;
+            const tw = topSize.w * scale;
+            const td = topSize.h * scale;
+            linearDim(dimEntities, [frontCX + tw / 2, topCY - td / 2], [frontCX + tw / 2, topCY + td / 2], [1, 0], 9, trim(topSize.h));
+        }
+    }
+    // Iso: fit the right free column above the title block, independent scale.
+    if (iso !== undefined) {
+        const isoLeft = FRAME + (width - FRAME * 2) * 0.64 + GAP / 2;
+        const isoBottom = FRAME + TITLE_BLOCK.height + GAP / 2;
+        const cellW = Math.max(width - FRAME - isoLeft, 40);
+        const cellH = Math.max(height - FRAME - isoBottom, 40);
+        const isoSize = sizeOf(viewBounds(iso));
+        const s = fitScale(isoSize.w, isoSize.h, cellW - 10, cellH - 10);
+        const scaled = scaleView(iso, s);
+        const { tx, ty } = centerTransform(scaled, isoLeft + cellW / 2, isoBottom + cellH / 2);
+        placed.push({ view: scaled, tx, ty });
+    }
+    // ── entities ───────────────────────────────────────────────────────────────
+    const entities = [];
+    const frameRect = (x, y, w, h) => {
+        entities.push({ type: 'polyline', points: [x, y, x + w, y, x + w, y + h, x, y + h], closed: true, layer: 'paper', color: COLORS.paper });
+    };
+    frameRect(2, 2, width - 4, height - 4);
+    frameRect(FRAME, FRAME, width - FRAME * 2, height - FRAME * 2);
+    const tbX = width - FRAME - TITLE_BLOCK.width;
+    const tbY = FRAME;
+    frameRect(tbX, tbY, TITLE_BLOCK.width, TITLE_BLOCK.height);
+    entities.push({ type: 'line', x1: tbX, y1: tbY + TITLE_BLOCK.height / 2, x2: tbX + TITLE_BLOCK.width, y2: tbY + TITLE_BLOCK.height / 2, layer: 'paper', color: COLORS.paper });
+    entities.push({ type: 'line', x1: tbX + 78, y1: tbY, x2: tbX + 78, y2: tbY + TITLE_BLOCK.height, layer: 'paper', color: COLORS.paper });
+    const titleText = (x, y, text, size = 3.2) => {
+        entities.push({ type: 'text', x, y, text, height: size, layer: 'paper', color: COLORS.text });
+    };
+    titleText(tbX + 4, tbY + TITLE_BLOCK.height - 8, input.partName, 4.2);
+    titleText(tbX + 4, tbY + 6, `图号 ${input.drawingNo ?? '—'}`);
+    titleText(tbX + 44, tbY + 6, `比例 ${scaleText(scale)}`);
+    titleText(tbX + 82, tbY + 6, '单位 mm');
+    titleText(tbX + 82, tbY + TITLE_BLOCK.height / 2 - 4, `日期 ${input.date ?? ''}`);
+    entities.push(...dimEntities);
+    for (const item of placed) {
+        for (const polyline of item.view.visible) {
+            entities.push({
+                type: 'polyline',
+                points: polyline.map((v, i) => v + (i % 2 === 0 ? item.tx : item.ty)),
+                closed: false, layer: 'visible', color: COLORS.visible,
+            });
+        }
+        for (const polyline of item.view.hidden) {
+            entities.push({
+                type: 'polyline',
+                points: polyline.map((v, i) => v + (i % 2 === 0 ? item.tx : item.ty)),
+                closed: false, layer: 'hidden', color: COLORS.hidden,
+            });
+        }
+    }
+    return {
+        entities,
+        bounds: { min: { x: 0, y: 0 }, max: { x: width, y: height } },
+        layers: ['visible', 'hidden', 'dim', 'paper'],
+        width,
+        height,
+        scale,
+        entityCount: entities.length,
+    };
+}
+// ── export serializations ─────────────────────────────────────────────────────
+const esc = (text) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+/** Serialize the sheet to a standalone SVG (paper mm = user units, Y flipped). */
+export function drawingToSvg(sheet) {
+    const { width, height, entities } = sheet;
+    const parts = [];
+    parts.push(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}mm" height="${height}mm">`);
+    parts.push(`<rect x="0" y="0" width="${width}" height="${height}" fill="#ffffff"/>`);
+    parts.push(`<g transform="translate(0,${height}) scale(1,-1)">`);
+    for (const entity of entities) {
+        switch (entity.type) {
+            case 'line':
+                parts.push(`<line x1="${entity.x1}" y1="${entity.y1}" x2="${entity.x2}" y2="${entity.y2}" stroke="${cssColor(entity)}" ${strokeStyle(entity)}/>`);
+                break;
+            case 'polyline': {
+                const points = [];
+                for (let i = 0; i + 1 < entity.points.length; i += 2)
+                    points.push(`${entity.points[i]},${entity.points[i + 1]}`);
+                parts.push(`<polyline points="${points.join(' ')}" fill="none" stroke="${cssColor(entity)}" ${strokeStyle(entity)}/>`);
+                break;
+            }
+            case 'text':
+                parts.push(`<text x="${entity.x}" y="${entity.y}" font-size="${entity.height}" fill="${cssColor(entity)}" ` +
+                    `transform="translate(0,${2 * entity.y}) scale(1,-1)" font-family="sans-serif">${esc(entity.text)}</text>`);
+                break;
+            default:
+                break;
+        }
+    }
+    parts.push('</g></svg>');
+    return parts.join('\n');
+}
+function cssColor(entity) {
+    const color = entity.color ?? 0x1a1d21;
+    return `#${color.toString(16).padStart(6, '0')}`;
+}
+function strokeStyle(entity) {
+    const width = entity.layer === 'hidden' || entity.layer === 'dim' ? 0.25 : 0.45;
+    const dash = entity.layer === 'hidden' ? ' stroke-dasharray="2,1.2"' : '';
+    return `stroke-width="${width}"${dash}`;
+}
+/** Minimal R12 ASCII DXF (LINE + TEXT entities; polylines expand to lines). */
+export function drawingToDxf(sheet) {
+    const out = [];
+    const push = (code, value) => {
+        out.push(String(code), String(value));
+    };
+    push(0, 'SECTION');
+    push(2, 'ENTITIES');
+    for (const entity of sheet.entities) {
+        switch (entity.type) {
+            case 'line':
+                push(0, 'LINE');
+                push(8, entity.layer ?? '0');
+                push(10, entity.x1.toFixed(4));
+                push(20, entity.y1.toFixed(4));
+                push(30, '0');
+                push(11, entity.x2.toFixed(4));
+                push(21, entity.y2.toFixed(4));
+                push(31, '0');
+                break;
+            case 'polyline':
+                for (let i = 0; i + 3 < entity.points.length; i += 2) {
+                    push(0, 'LINE');
+                    push(8, entity.layer ?? '0');
+                    push(10, entity.points[i].toFixed(4));
+                    push(20, entity.points[i + 1].toFixed(4));
+                    push(30, '0');
+                    push(11, entity.points[i + 2].toFixed(4));
+                    push(21, entity.points[i + 3].toFixed(4));
+                    push(30, '0');
+                }
+                break;
+            case 'text':
+                push(0, 'TEXT');
+                push(8, entity.layer ?? '0');
+                push(10, entity.x.toFixed(4));
+                push(20, entity.y.toFixed(4));
+                push(30, '0');
+                push(40, entity.height.toFixed(3));
+                push(1, entity.text);
+                if (entity.rotation !== undefined)
+                    push(50, entity.rotation.toFixed(2));
+                break;
+            default:
+                break;
+        }
+    }
+    push(0, 'ENDSEC');
+    push(0, 'EOF');
+    return out.join('\n');
+}

package/lib/modeling/hlr.cjs

@@ -0,0 +1,328 @@
+/**
+ * Mesh-based hidden-line-removal projection (plain CJS — runs inside the
+ * modeling worker). The opencascade.js build exposes no HLRBRep bindings, so
+ * engineering-drawing views are computed from the tessellation instead:
+ *
+ *   1. candidate edges = sharp feature edges (dihedral > threshold, view
+ *      independent) ∪ silhouette edges (one adjacent face front-facing, one
+ *      back-facing — per view), which is what traces curved outlines;
+ *   2. each candidate is occlusion-tested against the projected triangle soup
+ *      via a uniform 2D grid (depth-interpolated barycentric coverage);
+ *   3. surviving edges are chained into polylines and simplified (RDP), so
+ *      the caller gets compact flat [x,y, x,y, …] paths per visibility class.
+ *
+ * Projected coordinates stay in model units (mm): u along the view's xDir,
+ * v = w × u (w = view direction toward the observer), so screen y is "up".
+ */
+'use strict'
+
+/**
+ * Build the edge table keyed by quantized endpoint COORDINATES (not vertex
+ * indices): OCCT triangulations are per-face, so the same topological edge
+ * appears once per adjacent face under different indices — only coordinates
+ * merge them. Values accumulate adjacent face normals for the dihedral test.
+ */
+function edgeTable(positions, indices) {
+  const q = (v) => Math.round(v * 1e4)
+  const edges = new Map()
+  const triCount = indices.length / 3
+  for (let t = 0; t < triCount; t++) {
+    const a = indices[t * 3]
+    const b = indices[t * 3 + 1]
+    const c = indices[t * 3 + 2]
+    const ax = positions[a * 3], ay = positions[a * 3 + 1], az = positions[a * 3 + 2]
+    const bx = positions[b * 3], by = positions[b * 3 + 1], bz = positions[b * 3 + 2]
+    const cx = positions[c * 3], cy = positions[c * 3 + 1], cz = positions[c * 3 + 2]
+    // Face normal (normalized; the winding is the orientation source of truth).
+    const ux = bx - ax, uy = by - ay, uz = bz - az
+    const vx = cx - ax, vy = cy - ay, vz = cz - az
+    let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx
+    const len = Math.hypot(nx, ny, nz) || 1
+    nx /= len; ny /= len; nz /= len
+    for (const [i, j] of [[a, b], [b, c], [c, a]]) {
+      const ka = `${q(positions[i * 3])},${q(positions[i * 3 + 1])},${q(positions[i * 3 + 2])}`
+      const kb = `${q(positions[j * 3])},${q(positions[j * 3 + 1])},${q(positions[j * 3 + 2])}`
+      const key = ka < kb ? `${ka};${kb}` : `${kb};${ka}`
+      let entry = edges.get(key)
+      if (entry === undefined) {
+        entry = { normals: [], x1: positions[i * 3], y1: positions[i * 3 + 1], z1: positions[i * 3 + 2], x2: positions[j * 3], y2: positions[j * 3 + 1], z2: positions[j * 3 + 2] }
+        edges.set(key, entry)
+      }
+      entry.normals.push([nx, ny, nz])
+    }
+  }
+  return edges
+}
+
+const cosThreshold = (angleDeg) => Math.cos((angleDeg * Math.PI) / 180)
+
+/**
+ * Sharp + boundary feature edges, view independent. Returns flat segments
+ * [x1,y1,z1, x2,y2,z2].
+ */
+function featureEdges(positions, indices, angleDeg = 25) {
+  return featureEdgesFrom(edgeTable(positions, indices), angleDeg)
+}
+
+function featureEdgesFrom(table, angleDeg = 25) {
+  const cosMin = cosThreshold(angleDeg)
+  const segments = []
+  for (const entry of table.values()) {
+    if (entry.normals.length === 1) {
+      // Boundary edge (open mesh) — always a candidate.
+    } else if (entry.normals.length === 2) {
+      const [n1, n2] = entry.normals
+      const dot = n1[0] * n2[0] + n1[1] * n2[1] + n1[2] * n2[2]
+      if (dot > cosMin) continue // smooth — not a feature edge
+    } else {
+      continue // non-manifold star: skip
+    }
+    segments.push(entry.x1, entry.y1, entry.z1, entry.x2, entry.y2, entry.z2)
+  }
+  return segments
+}
+
+/** Silhouette edges for one view: adjacent faces straddle the view plane. */
+function silhouetteEdges(positions, indices, dir) {
+  return silhouetteEdgesFrom(edgeTable(positions, indices), dir)
+}
+
+function silhouetteEdgesFrom(table, dir) {
+  const segments = []
+  for (const entry of table.values()) {
+    if (entry.normals.length !== 2) continue // boundary handled by the sharp pass
+    const [n1, n2] = entry.normals
+    const d1 = n1[0] * dir[0] + n1[1] * dir[1] + n1[2] * dir[2]
+    const d2 = n2[0] * dir[0] + n2[1] * dir[1] + n2[2] * dir[2]
+    if (d1 * d2 < 0) segments.push(entry.x1, entry.y1, entry.z1, entry.x2, entry.y2, entry.z2)
+  }
+  return segments
+}
+
+/** Occlusion tester over the projected triangle soup (uniform grid). */
+function createOccluderGrid(px, py, depth, indices, cellCount) {
+  const triCount = indices.length / 3
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity
+  for (let i = 0; i < px.length; i++) {
+    if (px[i] < minX) minX = px[i]
+    if (px[i] > maxX) maxX = px[i]
+    if (py[i] < minY) minY = py[i]
+    if (py[i] > maxY) maxY = py[i]
+  }
+  const extent = Math.max(maxX - minX, maxY - minY, 1e-9)
+  const cell = extent / cellCount
+  const grid = new Map()
+  const gridKey = (gx, gy) => gx * 4096 + gy
+  for (let t = 0; t < triCount; t++) {
+    const a = indices[t * 3] * 1, b = indices[t * 3 + 1], c = indices[t * 3 + 2]
+    const x0 = px[a], y0 = py[a], x1 = px[b], y1 = py[b], x2 = px[c], y2 = py[c]
+    const loX = Math.floor((Math.min(x0, x1, x2) - minX) / cell)
+    const hiX = Math.floor((Math.max(x0, x1, x2) - minX) / cell)
+    const loY = Math.floor((Math.min(y0, y1, y2) - minY) / cell)
+    const hiY = Math.floor((Math.max(y0, y1, y2) - minY) / cell)
+    for (let gy = loY; gy <= hiY; gy++) {
+      for (let gx = loX; gx <= hiX; gx++) {
+        const key = gridKey(gx, gy)
+        const bucket = grid.get(key)
+        if (bucket === undefined) grid.set(key, [t])
+        else bucket.push(t)
+      }
+    }
+  }
+  const EPS = extent * 1e-9
+  // Strict-interior margin: coverage only counts when the sample is a real
+  // distance inside the projected triangle. Orthographic projections make
+  // back faces share their boundary with the silhouette outline exactly —
+  // boundary-touching coverage must not hide the outline itself.
+  const MARGIN = 5e-3
+  /**
+   * Is (x, y) at depth `d` hidden? A triangle covers it when the projected
+   * point lies strictly inside and the interpolated depth is nearer by more
+   * than `bias` (bias ≈ half the tessellation chord sag to keep edges lying
+   * ON their own faces visible).
+   */
+  return (x, y, d, bias) => {
+    const gx = Math.floor((x - minX) / cell)
+    const gy = Math.floor((y - minY) / cell)
+    const bucket = grid.get(gridKey(gx, gy))
+    if (bucket === undefined) return false
+    for (const t of bucket) {
+      const a = indices[t * 3], b = indices[t * 3 + 1], c = indices[t * 3 + 2]
+      const x0 = px[a], y0 = py[a], x1 = px[b], y1 = py[b], x2 = px[c], y2 = py[c]
+      const area = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0)
+      if (Math.abs(area) < EPS) continue
+      const w0 = ((x1 - x) * (y2 - y) - (x2 - x) * (y1 - y)) / area
+      const w1 = ((x2 - x) * (y0 - y) - (x0 - x) * (y2 - y)) / area
+      const w2 = 1 - w0 - w1
+      if (w0 < MARGIN || w1 < MARGIN || w2 < MARGIN) continue
+      const frontDepth = w0 * depth[a] + w1 * depth[b] + w2 * depth[c]
+      if (frontDepth > d + bias) return true
+    }
+    return false
+  }
+}
+
+/** Ramer–Douglas–Peucker on a flat [x,y,…] polyline. */
+function simplify(points, epsilon) {
+  const n = points.length / 2
+  if (n < 3) return points
+  const keep = new Uint8Array(n)
+  keep[0] = 1
+  keep[n - 1] = 1
+  const stack = [[0, n - 1]]
+  while (stack.length > 0) {
+    const [first, last] = stack.pop()
+    const x1 = points[first * 2], y1 = points[first * 2 + 1]
+    const x2 = points[last * 2], y2 = points[last * 2 + 1]
+    const dx = x2 - x1, dy = y2 - y1
+    const len = Math.hypot(dx, dy)
+    let maxDist = 0
+    let index = -1
+    for (let i = first + 1; i < last; i++) {
+      const px = points[i * 2], py = points[i * 2 + 1]
+      const dist = len === 0 ? Math.hypot(px - x1, py - y1) : Math.abs(dy * px - dx * py + x2 * y1 - y2 * x1) / len
+      if (dist > maxDist) { maxDist = dist; index = i }
+    }
+    if (maxDist > epsilon && index > 0) {
+      keep[index] = 1
+      stack.push([first, index], [index, last])
+    }
+  }
+  const out = []
+  for (let i = 0; i < n; i++) {
+    if (keep[i]) { out.push(points[i * 2], points[i * 2 + 1]) }
+  }
+  return out
+}
+
+/** Chain collinear-adjacent segments ([x1,y1,x2,y2] tuples) into polylines. */
+function chainSegments(segments) {
+  const key = (x, y) => `${Math.round(x * 1000)}|${Math.round(y * 1000)}`
+  const map = new Map()
+  segments.forEach((seg, s) => {
+    const [x1, y1, x2, y2] = seg
+    for (const [k, end] of [[key(x1, y1), 0], [key(x2, y2), 1]]) {
+      let list = map.get(k)
+      if (list === undefined) { list = []; map.set(k, list) }
+      list.push({ s, end })
+    }
+  })
+  const used = new Uint8Array(segments.length)
+  const chains = []
+  for (let s = 0; s < segments.length; s++) {
+    if (used[s]) continue
+    used[s] = 1
+    const chain = [segments[s][0], segments[s][1], segments[s][2], segments[s][3]]
+    // Extend forward from the tail, then backward from the head.
+    for (const direction of [1, -1]) {
+      for (;;) {
+        const tailX = direction === 1 ? chain[chain.length - 2] : chain[0]
+        const tailY = direction === 1 ? chain[chain.length - 1] : chain[1]
+        const candidates = map.get(key(tailX, tailY)) ?? []
+        let found = null
+        for (const candidate of candidates) {
+          if (used[candidate.s]) continue
+          found = candidate
+          break
+        }
+        if (found === null) break
+        used[found.s] = 1
+        const [ex1, ey1, ex2, ey2] = segments[found.s]
+        // Append the far end oriented away from the join point.
+        const joinIsStart = key(ex1, ey1) === key(tailX, tailY)
+        const px = joinIsStart ? ex2 : ex1
+        const py = joinIsStart ? ey2 : ey1
+        if (direction === 1) chain.push(px, py)
+        else chain.unshift(px, py)
+      }
+    }
+    chains.push(chain)
+  }
+  return chains
+}
+
+/**
+ * Project one tessellated body into drawing views.
+ * views: [{ name, dir:[x,y,z] toward observer, xDir:[x,y,z] screen-right }].
+ * Returns { views: [{ name, visible: number[][] (flat polylines), hidden: number[][] }] }.
+ */
+function projectViews({ positions, indices }, views, options = {}) {
+  const sharpAngle = options.sharpAngle ?? 25
+  const table = edgeTable(positions, indices)
+  const sharp = featureEdgesFrom(table, sharpAngle)
+  const triCount = indices.length / 3
+  const modelScale = (() => {
+    let min = Infinity, max = -Infinity
+    for (let i = 0; i < positions.length; i++) {
+      if (positions[i] < min) min = positions[i]
+      if (positions[i] > max) max = positions[i]
+    }
+    return Math.max(max - min, 1e-9)
+  })()
+  const bias = modelScale * (options.biasRatio ?? 0.002)
+  const simplifyEps = modelScale * (options.simplifyRatio ?? 0.0012)
+
+  return {
+    views: views.map((view) => {
+      const w = normalize(view.dir)
+      let u = normalize(view.xDir)
+      if (Math.abs(dot(u, w)) > 0.999) u = [1, 0, 0] // degenerate xDir fallback
+      const v = normalize(cross(w, u))
+      const count = positions.length / 3
+      const px = new Float64Array(count)
+      const py = new Float64Array(count)
+      const depth = new Float64Array(count)
+      for (let i = 0; i < count; i++) {
+        const x = positions[i * 3], y = positions[i * 3 + 1], z = positions[i * 3 + 2]
+        px[i] = x * u[0] + y * u[1] + z * u[2]
+        py[i] = x * v[0] + y * v[1] + z * v[2]
+        depth[i] = x * w[0] + y * w[1] + z * w[2]
+      }
+      const occluded = createOccluderGrid(px, py, depth, indices, 48)
+      const candidates = [...sharp, ...silhouetteEdgesFrom(table, w)]
+      const visibleSegments = []
+      const hiddenSegments = []
+      for (let s = 0; s < candidates.length / 6; s++) {
+        const x1 = candidates[s * 6], y1 = candidates[s * 6 + 1], z1 = candidates[s * 6 + 2]
+        const x2 = candidates[s * 6 + 3], y2 = candidates[s * 6 + 4], z2 = candidates[s * 6 + 5]
+        const p1x = x1 * u[0] + y1 * u[1] + z1 * u[2]
+        const p1y = x1 * v[0] + y1 * v[1] + z1 * v[2]
+        const p2x = x2 * u[0] + y2 * u[1] + z2 * u[2]
+        const p2y = x2 * v[0] + y2 * v[1] + z2 * v[2]
+        if (Math.abs(p1x - p2x) < 1e-9 && Math.abs(p1y - p2y) < 1e-9) continue
+        const d1 = x1 * w[0] + y1 * w[1] + z1 * w[2]
+        const d2 = x2 * w[0] + y2 * w[1] + z2 * w[2]
+        // Three interior samples, majority vote.
+        let hits = 0
+        for (const t of [0.25, 0.5, 0.75]) {
+          const sx = p1x + (p2x - p1x) * t
+          const sy = p1y + (p2y - p1y) * t
+          const sd = d1 + (d2 - d1) * t
+          if (occluded(sx, sy, sd, bias)) hits++
+        }
+        const target = hits >= 2 ? hiddenSegments : visibleSegments
+        target.push([p1x, p1y, p2x, p2y])
+      }
+      const unwrap = (segments) =>
+        chainSegments(segments)
+          .map((chain) => simplify(chain, simplifyEps))
+          .filter((chain) => chain.length >= 4)
+      return { name: view.name, visible: unwrap(visibleSegments), hidden: unwrap(hiddenSegments) }
+    }),
+  }
+}
+
+function normalize(v) {
+  const len = Math.hypot(v[0], v[1], v[2]) || 1
+  return [v[0] / len, v[1] / len, v[2] / len]
+}
+
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
+}
+
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+}
+
+module.exports = { featureEdges, silhouetteEdges, projectViews }