@twinfinity/printing 5.0.3-ci.28538-beta

package/src/printToSvg.ts

@@ -0,0 +1,188 @@
+import type { SlabSectionGeometry, Vec3 } from '@twinfinity/geometry';
+import type { PrintToSvgOptions, SvgRenderStyles, SvgPlaneBasis } from './types';
+import { DEFAULT_SVG_STYLES } from './types';
+
+type Pt2 = { x: number; y: number };
+type Bounds = { minX: number; maxX: number; minY: number; maxY: number };
+
+/**
+ * Render SlabSectionGeometry to an SVG string.
+ *
+ * @param geometry The computed slab section geometry
+ * @param options Rendering options (viewBox, styles, planeBasis, etc.)
+ * @returns Complete SVG string
+ */
+export function printToSvg(geometry: SlabSectionGeometry, options: PrintToSvgOptions = {}): string {
+    if (!geometry) throw new Error('geometry is required');
+
+    if (
+        options.boundsPadding !== undefined &&
+        (typeof options.boundsPadding !== 'number' || options.boundsPadding < 0)
+    ) {
+        throw new Error('boundsPadding must be a non-negative number');
+    }
+
+    if (options.viewBox) {
+        if (!Array.isArray(options.viewBox) || options.viewBox.length !== 4) {
+            throw new Error('viewBox must be an array of 4 numbers [minX, minY, width, height]');
+        }
+        for (let i = 0; i < 4; i++) {
+            if (typeof options.viewBox[i] !== 'number' || !Number.isFinite(options.viewBox[i])) {
+                throw new Error(`viewBox[${i}] must be a finite number`);
+            }
+        }
+    }
+
+    const styles = mergeStyles(options.styles);
+    const includeXml = options.includeXmlDeclaration ?? true;
+
+    // Project all polylines to 2D once
+    const proj = {
+        hiddenLines: projectPolylines(geometry.hiddenLines, options.planeBasis),
+        outlineHidden: projectPolylines(geometry.outlineHidden, options.planeBasis),
+        visibleLines: projectPolylines(geometry.visibleLines, options.planeBasis),
+        outlineVisible: projectPolylines(geometry.outlineVisible, options.planeBasis),
+        silhouettes: projectPolylines(geometry.silhouettes, options.planeBasis),
+        featureEdges: projectPolylines(geometry.featureEdges, options.planeBasis),
+        cutLines: projectPolylines(geometry.cutLines, options.planeBasis),
+        stairArrows: projectPolylines(geometry.stairArrows, options.planeBasis)
+    };
+
+    const bounds = options.bounds ?? computeBoundsFromProjected(proj);
+    const viewBox = options.viewBox ?? boundsToViewBox(bounds, options.boundsPadding ?? 0.05);
+
+    const parts: string[] = [];
+
+    if (includeXml) parts.push('<?xml version="1.0" encoding="UTF-8"?>');
+
+    const [minX, minY, width, height] = viewBox;
+    parts.push(
+        `<svg xmlns="http://www.w3.org/2000/svg" ` +
+            `viewBox="${minX} ${minY} ${width} ${height}" ` +
+            `width="${width}" height="${height}">`
+    );
+
+    if (options.backgroundColor) {
+        parts.push(
+            `<rect x="${minX}" y="${minY}" width="${width}" height="${height}" fill="${options.backgroundColor}"/>`
+        );
+    }
+
+    parts.push('<g fill="none" stroke-linecap="round" stroke-linejoin="round">');
+
+    const categories: Array<[keyof typeof proj, keyof Required<SvgRenderStyles>]> = [
+        ['hiddenLines', 'hiddenLines'],
+        ['outlineHidden', 'outlineHidden'],
+        ['visibleLines', 'visibleLines'],
+        ['outlineVisible', 'outlineVisible'],
+        ['silhouettes', 'silhouettes'],
+        ['featureEdges', 'featureEdges'],
+        ['cutLines', 'cutLines'],
+        ['stairArrows', 'stairArrows']
+    ];
+
+    for (const [key, styleKey] of categories) {
+        const style = styles[styleKey];
+        if (style.enabled) renderProjectedCategory(parts, proj[key], style, bounds);
+    }
+
+    parts.push('</g>');
+    parts.push('</svg>');
+    return parts.join('\n');
+}
+
+function projectPolylines(polylines: Vec3[][], planeBasis?: SvgPlaneBasis): Pt2[][] {
+    const result: Pt2[][] = [];
+    for (const polyline of polylines) {
+        if (polyline.length === 0) continue;
+        const projected: Pt2[] = [];
+        for (const point of polyline) {
+            if (!Number.isFinite(point[0]) || !Number.isFinite(point[1]) || !Number.isFinite(point[2])) continue;
+            if (planeBasis) {
+                const dx = point[0] - planeBasis.origin.x;
+                const dy = point[1] - planeBasis.origin.y;
+                const dz = point[2] - planeBasis.origin.z;
+                projected.push({
+                    x: dx * planeBasis.right.x + dy * planeBasis.right.y + dz * planeBasis.right.z,
+                    y: dx * planeBasis.up.x + dy * planeBasis.up.y + dz * planeBasis.up.z
+                });
+            } else {
+                projected.push({ x: point[0], y: -point[2] });
+            }
+        }
+        if (projected.length > 0) result.push(projected);
+    }
+    return result;
+}
+
+function computeBoundsFromProjected(categories: Record<string, Pt2[][]>): Bounds {
+    let minX = Infinity,
+        minY = Infinity,
+        maxX = -Infinity,
+        maxY = -Infinity;
+    for (const polylines of Object.values(categories)) {
+        for (const polyline of polylines) {
+            for (const pt of polyline) {
+                if (pt.x < minX) minX = pt.x;
+                if (pt.x > maxX) maxX = pt.x;
+                if (pt.y < minY) minY = pt.y;
+                if (pt.y > maxY) maxY = pt.y;
+            }
+        }
+    }
+    if (!Number.isFinite(minX)) return { minX: 0, maxX: 1, minY: 0, maxY: 1 };
+    return { minX, maxX, minY, maxY };
+}
+
+function renderProjectedCategory(
+    parts: string[],
+    polylines: Pt2[][],
+    style: { stroke?: string; strokeWidth?: number; strokeDasharray?: string; opacity?: number },
+    bounds: Bounds
+): void {
+    if (!polylines.length) return;
+    const pathData = projectedToPathData(polylines, bounds);
+    if (!pathData) return;
+
+    let pathElement = `<path d="${pathData}"`;
+    if (style.stroke) pathElement += ` stroke="${style.stroke}"`;
+    if (style.strokeWidth !== undefined) pathElement += ` stroke-width="${style.strokeWidth}"`;
+    if (style.strokeDasharray) pathElement += ` stroke-dasharray="${style.strokeDasharray}"`;
+    if (style.opacity !== undefined && style.opacity !== 1) pathElement += ` opacity="${style.opacity}"`;
+    pathElement += '/>';
+    parts.push(pathElement);
+}
+
+function projectedToPathData(polylines: Pt2[][], bounds: Bounds): string {
+    const parts: string[] = [];
+    const ox = bounds.minX;
+    const oy = bounds.maxY;
+    for (const polyline of polylines) {
+        if (polyline.length === 0) continue;
+        parts.push(`M ${(polyline[0].x - ox).toFixed(6)} ${(oy - polyline[0].y).toFixed(6)}`);
+        for (let i = 1; i < polyline.length; i++) {
+            parts.push(`L ${(polyline[i].x - ox).toFixed(6)} ${(oy - polyline[i].y).toFixed(6)}`);
+        }
+    }
+    return parts.join(' ');
+}
+
+function boundsToViewBox(bounds: Bounds, padding: number): [number, number, number, number] {
+    const width = bounds.maxX - bounds.minX;
+    const height = bounds.maxY - bounds.minY;
+    const padAmount = Math.max(width, height) * padding;
+    return [-padAmount, -padAmount, width + padAmount * 2, height + padAmount * 2];
+}
+
+function mergeStyles(userStyles?: SvgRenderStyles): Required<SvgRenderStyles> {
+    return {
+        cutLines: { ...DEFAULT_SVG_STYLES.cutLines, ...userStyles?.cutLines },
+        visibleLines: { ...DEFAULT_SVG_STYLES.visibleLines, ...userStyles?.visibleLines },
+        hiddenLines: { ...DEFAULT_SVG_STYLES.hiddenLines, ...userStyles?.hiddenLines },
+        silhouettes: { ...DEFAULT_SVG_STYLES.silhouettes, ...userStyles?.silhouettes },
+        featureEdges: { ...DEFAULT_SVG_STYLES.featureEdges, ...userStyles?.featureEdges },
+        stairArrows: { ...DEFAULT_SVG_STYLES.stairArrows, ...userStyles?.stairArrows },
+        outlineVisible: { ...DEFAULT_SVG_STYLES.outlineVisible, ...userStyles?.outlineVisible },
+        outlineHidden: { ...DEFAULT_SVG_STYLES.outlineHidden, ...userStyles?.outlineHidden }
+    };
+}