dsh-cad 0.2.0

package/lib/convert/stl.js

@@ -0,0 +1,110 @@
+import { encodeF32B64, encodeU32B64 } from '../b64.js';
+const BINARY_HEADER_SIZE = 80;
+const BINARY_TRIANGLE_SIZE = 50; // 12 normal + 36 vertices + 2 count
+/** Decide binary vs ASCII by the classic solid-prefix heuristic. */
+function isAscii(buffer) {
+    const head = buffer.subarray(0, Math.min(buffer.length, 512)).toString('latin1').trimStart();
+    return head.startsWith('solid') && !looksBinary(buffer);
+}
+function looksBinary(buffer) {
+    if (buffer.length < BINARY_HEADER_SIZE + 4)
+        return true;
+    const triangleCount = buffer.readUInt32LE(BINARY_HEADER_SIZE);
+    const expected = BINARY_HEADER_SIZE + 4 + triangleCount * BINARY_TRIANGLE_SIZE;
+    return buffer.length === expected;
+}
+/** Weld positions by exact float-key to index STL's raw triangle soup. */
+function indexTriangleSoup(triangles, triangleCount, normals) {
+    const vertexMap = new Map();
+    const positions = [];
+    const indices = [];
+    const dedupNormals = [];
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+        const base = triangle * 9;
+        for (let corner = 0; corner < 3; corner++) {
+            const v = base + corner * 3;
+            const key = `${triangles[v]},${triangles[v + 1]},${triangles[v + 2]}`;
+            let index = vertexMap.get(key);
+            if (index === undefined) {
+                index = positions.length / 3;
+                vertexMap.set(key, index);
+                positions.push(triangles[v], triangles[v + 1], triangles[v + 2]);
+                if (normals !== null) {
+                    const n = base - (base % 9) + 0; // normal of this triangle (same for 3 corners)
+                    dedupNormals.push(normals[n], normals[n + 1], normals[n + 2]);
+                }
+            }
+            indices.push(index);
+        }
+    }
+    return {
+        positions: Float32Array.from(positions),
+        normals: normals === null ? null : Float32Array.from(dedupNormals),
+        indices: Uint32Array.from(indices),
+    };
+}
+function parseBinary(buffer) {
+    const triangleCount = buffer.readUInt32LE(BINARY_HEADER_SIZE);
+    const triangles = new Float32Array(triangleCount * 9);
+    const normals = new Float32Array(triangleCount * 3);
+    let offset = BINARY_HEADER_SIZE + 4;
+    for (let triangle = 0; triangle < triangleCount; triangle++) {
+        normals[triangle * 3] = buffer.readFloatLE(offset);
+        normals[triangle * 3 + 1] = buffer.readFloatLE(offset + 4);
+        normals[triangle * 3 + 2] = buffer.readFloatLE(offset + 8);
+        offset += 12;
+        for (let corner = 0; corner < 9; corner++) {
+            triangles[triangle * 9 + corner] = buffer.readFloatLE(offset);
+            offset += 4;
+        }
+        offset += 2; // attribute byte count
+    }
+    return indexTriangleSoup(triangles, triangleCount, normals);
+}
+/** Parse ASCII STL: `vertex x y z` triplets grouped into facet loops. */
+function parseAscii(text) {
+    const vertices = [];
+    const normals = [];
+    let currentNormal = null;
+    let cornersInFacet = 0;
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        const lower = trimmed.toLowerCase();
+        if (lower.startsWith('facet normal')) {
+            const parts = lower.split(/\s+/);
+            currentNormal = [Number(parts[2]), Number(parts[3]), Number(parts[4])];
+            cornersInFacet = 0;
+        }
+        else if (lower.startsWith('vertex')) {
+            const parts = lower.split(/\s+/);
+            vertices.push(Number(parts[1]), Number(parts[2]), Number(parts[3]));
+            if (cornersInFacet === 0 && currentNormal !== null) {
+                normals.push(currentNormal[0], currentNormal[1], currentNormal[2]);
+            }
+            cornersInFacet++;
+        }
+        else if (lower.startsWith('endfacet')) {
+            // Facets with fewer or more than 3 vertices are malformed; STL requires 3.
+            if (cornersInFacet !== 3)
+                throw new Error(`malformed ASCII STL facet: expected 3 vertices, found ${cornersInFacet}`);
+        }
+    }
+    const triangleCount = vertices.length / 9;
+    if (!Number.isInteger(triangleCount) || triangleCount === 0)
+        throw new Error('malformed ASCII STL: no complete facets');
+    return indexTriangleSoup(Float32Array.from(vertices), triangleCount, Float32Array.from(normals));
+}
+/** Convert an STL buffer into one indexed CadMesh. */
+export function parseSTL(buffer, name) {
+    const mesh = isAscii(buffer) ? parseAscii(buffer.toString('latin1')) : parseBinary(buffer);
+    return {
+        name,
+        positions: encodeF32B64(mesh.positions),
+        normals: mesh.normals === null ? undefined : encodeF32B64(mesh.normals),
+        indices: encodeU32B64(mesh.indices),
+        vertexCount: mesh.positions.length / 3,
+        triangleCount: mesh.indices.length / 3,
+    };
+}

package/lib/convert/svg.js

@@ -0,0 +1,101 @@
+function numberAttribute(tag, name, fallback = 0) {
+    const match = tag.match(new RegExp(`${name}\\s*=\\s*"([^"]*)"`));
+    if (match === null)
+        return fallback;
+    const value = Number(match[1]);
+    return Number.isFinite(value) ? value : fallback;
+}
+function colorAttribute(tag) {
+    const stroke = tag.match(/stroke\s*=\s*"#([0-9a-fA-F]{6})"/);
+    if (stroke === null || stroke[1] === 'none')
+        return undefined;
+    return parseInt(stroke[1], 16);
+}
+/** Extract the renderable entity subset from an SVG document. */
+export function parseSVG(text) {
+    const entities = [];
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const track = (x, y) => {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    };
+    // User-space y grows downward in SVG; flip into math orientation.
+    const flipY = (text.match(/\by2?\s*=\s*"/) !== null);
+    const maybeFlip = (y) => (flipY ? -y : y);
+    for (const tag of text.matchAll(/<(line|circle|rect|polyline)\b[^>]*>/gi)) {
+        const element = tag[0];
+        const kind = tag[1].toLowerCase();
+        const color = colorAttribute(element);
+        switch (kind) {
+            case 'line': {
+                const x1 = numberAttribute(element, 'x1');
+                const y1 = maybeFlip(numberAttribute(element, 'y1'));
+                const x2 = numberAttribute(element, 'x2');
+                const y2 = maybeFlip(numberAttribute(element, 'y2'));
+                entities.push({ type: 'line', x1, y1, x2, y2, color });
+                track(x1, y1);
+                track(x2, y2);
+                break;
+            }
+            case 'circle': {
+                const cx = numberAttribute(element, 'cx');
+                const cy = maybeFlip(numberAttribute(element, 'cy'));
+                const r = numberAttribute(element, 'r');
+                entities.push({ type: 'circle', cx, cy, r, color });
+                track(cx - r, cy - r);
+                track(cx + r, cy + r);
+                break;
+            }
+            case 'rect': {
+                const x = numberAttribute(element, 'x');
+                const y = maybeFlip(numberAttribute(element, 'y'));
+                const width = numberAttribute(element, 'width');
+                const height = numberAttribute(element, 'height');
+                const points = [x, y, x + width, y, x + width, y - height, x, y - height];
+                entities.push({ type: 'polyline', points, closed: true, color });
+                track(x, y - height);
+                track(x + width, y);
+                break;
+            }
+            case 'polyline': {
+                const pointsMatch = element.match(/points\s*=\s*"([^"]*)"/);
+                if (pointsMatch === null)
+                    break;
+                const points = [];
+                for (const pair of pointsMatch[1].trim().split(/\s+/)) {
+                    const [xs, ys] = pair.split(',');
+                    const x = Number(xs);
+                    const y = Number(ys);
+                    if (Number.isFinite(x) && Number.isFinite(y)) {
+                        points.push(x, maybeFlip(y));
+                        track(x, maybeFlip(y));
+                    }
+                }
+                if (points.length >= 4)
+                    entities.push({ type: 'polyline', points, closed: element.includes('polygon'), color });
+                break;
+            }
+        }
+    }
+    if (!Number.isFinite(minX)) {
+        const width = numberAttribute(text.match(/<svg\b[^>]*>/)?.[0] ?? '', 'width', 100);
+        const height = numberAttribute(text.match(/<svg\b[^>]*>/)?.[0] ?? '', 'height', 100);
+        minX = 0;
+        minY = -height;
+        maxX = width;
+        maxY = 0;
+    }
+    return {
+        kind: '2d',
+        format: 'svg',
+        entities,
+        bounds: { min: { x: minX, y: minY }, max: { x: maxX, y: maxY } },
+        layers: [],
+        svgText: text,
+    };
+}