fluidcad 0.0.2

package/lib/dist/oc/io.js

@@ -0,0 +1,417 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+import { Solid } from "../common/solid.js";
+import { Face } from "../common/face.js";
+import { ShapeFactory } from "../common/shape-factory.js";
+export class OcIO {
+    // Wrapper methods (public API for external callers)
+    static readBRep(fileName, content) {
+        const raw = OcIO.readBRepRaw(fileName, content);
+        return ShapeFactory.fromShape(raw);
+    }
+    static writeBRep(shape, fileName) {
+        return OcIO.writeBRepRaw(shape.getShape(), fileName);
+    }
+    static readStep(fileName, data) {
+        const raw = OcIO.readStepRaw(fileName, data);
+        return ShapeFactory.fromShape(raw);
+    }
+    static findSolids(shape) {
+        const oc = getOC();
+        const rawSolids = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_SOLID);
+        return rawSolids.map(s => Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+    }
+    static findFaces(shape) {
+        const oc = getOC();
+        const rawFaces = Explorer.findShapes(shape.getShape(), oc.TopAbs_ShapeEnum.TopAbs_FACE);
+        return rawFaces.map(f => Face.fromTopoDSFace(Explorer.toFace(f)));
+    }
+    static makeCompound(shapes) {
+        const raw = OcIO.makeCompoundRaw(shapes.map(s => s.getShape()));
+        return ShapeFactory.fromShape(raw);
+    }
+    static readBRepSolids(fileName, content) {
+        const raw = OcIO.readBRepRaw(fileName, content);
+        if (Explorer.isSolid(raw)) {
+            return [Solid.fromTopoDSSolid(Explorer.toSolid(raw))];
+        }
+        const oc = getOC();
+        const rawSolids = Explorer.findShapes(raw, oc.TopAbs_ShapeEnum.TopAbs_SOLID);
+        return rawSolids.map(s => Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+    }
+    static writeSolidsAsBRep(solids, fileName) {
+        const compound = OcIO.makeCompoundRaw(solids.map(s => s.getShape()));
+        return OcIO.writeBRepRaw(compound, fileName);
+    }
+    static extractSolidsAndColors(docHandle) {
+        const rawResult = OcIO.extractSolidsAndColorsRaw(docHandle);
+        return {
+            solids: rawResult.solids.map(entry => ({
+                shape: Solid.fromTopoDSSolid(Explorer.toSolid(entry.shape)),
+                faceColors: entry.faceColors,
+            })),
+        };
+    }
+    // Raw methods (for oc-internal use)
+    static readBRepRaw(fileName, content) {
+        const oc = getOC();
+        oc.FS.writeFile(fileName, content);
+        const shape = new oc.TopoDS_Shape();
+        const builder = new oc.BRep_Builder();
+        const progress = new oc.Message_ProgressRange();
+        console.log(`Deserializing shape from virtual file ${fileName}`);
+        oc.BRepTools.Read(shape, fileName, builder, progress);
+        console.log(`Shape deserialized from virtual file ${fileName} successfully`);
+        oc.FS.unlink(fileName);
+        progress.delete();
+        return shape;
+    }
+    static writeBRepRaw(shape, fileName) {
+        const oc = getOC();
+        console.log(`Serializing shape to file ${fileName} in virtual FS`);
+        const writeProgress = new oc.Message_ProgressRange();
+        oc.BRepTools.Write(shape, fileName, writeProgress);
+        const file = oc.FS.readFile(fileName, { encoding: "utf8" });
+        writeProgress.delete();
+        console.log(`Serialized shape to file ${fileName}, size: ${file.length} bytes`);
+        return file;
+    }
+    static readStepRaw(fileName, data) {
+        const oc = getOC();
+        const uint8 = new Uint8Array(data);
+        oc.FS.createDataFile("/", fileName, uint8, true, true, true);
+        const reader = new oc.STEPControl_Reader();
+        const readResult = reader.ReadFile(fileName);
+        if (readResult !== oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+            oc.FS.unlink(fileName);
+            reader.delete();
+            throw new Error(`Failed to read STEP file. Status: ${readResult}`);
+        }
+        const progress = new oc.Message_ProgressRange();
+        reader.TransferRoots(progress);
+        progress.delete();
+        const shape = reader.OneShape();
+        reader.delete();
+        oc.FS.unlink(fileName);
+        return shape;
+    }
+    static readStepXCAF(fileName, data) {
+        const oc = getOC();
+        const uint8 = new Uint8Array(data);
+        oc.FS.createDataFile("/", fileName, uint8, true, true, true);
+        const app = new oc.TDocStd_Application();
+        const docHandle = new oc.Handle_TDocStd_Document();
+        const format = new oc.TCollection_ExtendedString('MDTV-XCAF');
+        app.NewDocument(format, docHandle);
+        format.delete();
+        const reader = new oc.STEPCAFControl_Reader();
+        reader.SetColorMode(true);
+        reader.SetNameMode(true);
+        reader.SetLayerMode(true);
+        reader.SetPropsMode(true);
+        reader.SetSHUOMode(true);
+        reader.SetMatMode(true);
+        const readResult = reader.ReadFile(fileName);
+        if (readResult !== oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+            oc.FS.unlink(fileName);
+            reader.delete();
+            docHandle.delete();
+            app.delete();
+            throw new Error(`Failed to read STEP file. Status: ${readResult}`);
+        }
+        const transferProgress = new oc.Message_ProgressRange();
+        const transferred = reader.Transfer(docHandle, transferProgress);
+        transferProgress.delete();
+        if (!transferred) {
+            oc.FS.unlink(fileName);
+            reader.delete();
+            docHandle.delete();
+            app.delete();
+            throw new Error('STEP transfer failed');
+        }
+        const cleanup = () => {
+            reader.delete();
+            oc.FS.unlink(fileName);
+            app.Close(docHandle);
+            docHandle.delete();
+            app.delete();
+        };
+        return { docHandle, cleanup };
+    }
+    static castToSolid(shape) {
+        return Explorer.toSolid(shape);
+    }
+    static findSolidsRaw(shape) {
+        const oc = getOC();
+        return Explorer.findShapes(shape, oc.TopAbs_ShapeEnum.TopAbs_SOLID);
+    }
+    static findFacesRaw(shape) {
+        const oc = getOC();
+        return Explorer.findShapes(shape, oc.TopAbs_ShapeEnum.TopAbs_FACE);
+    }
+    static makeCompoundRaw(shapes) {
+        const oc = getOC();
+        const compound = new oc.TopoDS_Compound();
+        const builder = new oc.BRep_Builder();
+        builder.MakeCompound(compound);
+        for (const shape of shapes) {
+            builder.Add(compound, shape);
+        }
+        return compound;
+    }
+    static extractSolidsAndColorsRaw(docHandle) {
+        const oc = getOC();
+        const doc = docHandle.get();
+        const shapeToolHandle = oc.XCAFDoc_DocumentTool.ShapeTool(doc.Main());
+        const colorToolHandle = oc.XCAFDoc_DocumentTool.ColorTool(doc.Main());
+        const shapeTool = shapeToolHandle.get();
+        const colorTool = colorToolHandle.get();
+        const surfType = oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf;
+        const colorLabels = new oc.TDF_LabelSequence();
+        colorTool.GetColors(colorLabels);
+        console.log(`Total color definitions in document: ${colorLabels.Length()}`);
+        colorLabels.delete();
+        const faceColorByHash = new Map();
+        const solidColorByHash = new Map();
+        const allLabels = new oc.TDF_LabelSequence();
+        shapeTool.GetShapes(allLabels);
+        let simpleShapeCount = 0;
+        let subShapeColorCount = 0;
+        for (let i = 1; i <= allLabels.Length(); i++) {
+            const label = allLabels.Value(i);
+            if (!oc.XCAFDoc_ShapeTool.IsSimpleShape(label))
+                continue;
+            simpleShapeCount++;
+            const shape = oc.XCAFDoc_ShapeTool.GetShape(label);
+            const labelColor = new oc.Quantity_Color();
+            if (colorTool.GetColor(label, surfType, labelColor)) {
+                const hex = OcIO.rgbToHex(labelColor.Red(), labelColor.Green(), labelColor.Blue());
+                const labelSolids = OcIO.findSolidsRaw(shape);
+                for (const s of labelSolids) {
+                    solidColorByHash.set(s.HashCode(2147483647), hex);
+                }
+                const labelFaces = OcIO.findFacesRaw(shape);
+                for (const f of labelFaces) {
+                    faceColorByHash.set(f.HashCode(2147483647), hex);
+                }
+            }
+            labelColor.delete();
+            const subLabels = new oc.TDF_LabelSequence();
+            oc.XCAFDoc_ShapeTool.GetSubShapes(label, subLabels);
+            for (let j = 1; j <= subLabels.Length(); j++) {
+                const subLabel = subLabels.Value(j);
+                const subColor = new oc.Quantity_Color();
+                if (colorTool.GetColor(subLabel, surfType, subColor)) {
+                    const subShape = oc.XCAFDoc_ShapeTool.GetShape(subLabel);
+                    faceColorByHash.set(subShape.HashCode(2147483647), OcIO.rgbToHex(subColor.Red(), subColor.Green(), subColor.Blue()));
+                    subShapeColorCount++;
+                }
+                subColor.delete();
+            }
+            subLabels.delete();
+        }
+        allLabels.delete();
+        console.log(`Label tree: ${simpleShapeCount} simple shapes, ${subShapeColorCount} sub-shape colors, ${faceColorByHash.size} face entries, ${solidColorByHash.size} solid entries`);
+        const freeLabels = new oc.TDF_LabelSequence();
+        shapeTool.GetFreeShapes(freeLabels);
+        const solids = [];
+        for (let i = 1; i <= freeLabels.Length(); i++) {
+            const label = freeLabels.Value(i);
+            const rootShape = oc.XCAFDoc_ShapeTool.GetShape(label);
+            const solidShapes = OcIO.findSolidsRaw(rootShape);
+            for (const solidShape of solidShapes) {
+                const faces = OcIO.findFacesRaw(solidShape);
+                const faceColors = [];
+                for (let fi = 0; fi < faces.length; fi++) {
+                    const face = faces[fi];
+                    const color = OcIO.findFaceColor(face, solidShape, colorTool, shapeTool, oc, surfType, faceColorByHash, solidColorByHash);
+                    if (color) {
+                        faceColors.push({ faceIndex: fi, color });
+                    }
+                }
+                solids.push({ shape: solidShape, faceColors });
+            }
+        }
+        freeLabels.delete();
+        shapeToolHandle.delete();
+        colorToolHandle.delete();
+        return { solids };
+    }
+    static writeStepRaw(compound, fileName) {
+        const oc = getOC();
+        const writer = new oc.STEPControl_Writer();
+        const progress = new oc.Message_ProgressRange();
+        const status = writer.Transfer(compound, oc.STEPControl_StepModelType.STEPControl_AsIs, true, progress);
+        progress.delete();
+        if (status !== oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+            writer.delete();
+            throw new Error(`STEP transfer failed. Status: ${status}`);
+        }
+        const writeStatus = writer.Write(fileName);
+        if (writeStatus !== oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+            writer.delete();
+            throw new Error(`STEP write failed. Status: ${writeStatus}`);
+        }
+        const file = oc.FS.readFile(fileName, { encoding: "utf8" });
+        oc.FS.unlink(fileName);
+        writer.delete();
+        return file;
+    }
+    static writeStepXCAF(solids, fileName) {
+        const oc = getOC();
+        const app = new oc.TDocStd_Application();
+        const docHandle = new oc.Handle_TDocStd_Document();
+        const format = new oc.TCollection_ExtendedString('MDTV-XCAF');
+        app.NewDocument(format, docHandle);
+        format.delete();
+        const doc = docHandle.get();
+        const shapeToolHandle = oc.XCAFDoc_DocumentTool.ShapeTool(doc.Main());
+        const colorToolHandle = oc.XCAFDoc_DocumentTool.ColorTool(doc.Main());
+        const shapeTool = shapeToolHandle.get();
+        const colorTool = colorToolHandle.get();
+        const surfType = oc.XCAFDoc_ColorType.XCAFDoc_ColorSurf;
+        // Use NewShape + SetShape (per OCC docs) instead of AddShape to avoid
+        // compound wrapping that triggers multi-file assembly output.
+        for (const solid of solids) {
+            const label = shapeTool.NewShape();
+            shapeTool.SetShape(label, solid.getShape());
+            for (const entry of solid.colorMap) {
+                const [r, g, b] = OcIO.hexToRgb(entry.color);
+                const color = new oc.Quantity_Color(r, g, b, oc.Quantity_TypeOfColor.Quantity_TOC_RGB);
+                colorTool.SetColor(entry.shape, color, surfType);
+                color.delete();
+            }
+        }
+        shapeTool.UpdateAssemblies();
+        const cleanup = () => {
+            shapeToolHandle.delete();
+            colorToolHandle.delete();
+            app.Close(docHandle);
+            docHandle.delete();
+        };
+        const writer = new oc.STEPCAFControl_Writer();
+        writer.SetColorMode(true);
+        writer.SetNameMode(true);
+        const progress = new oc.Message_ProgressRange();
+        const transferred = writer.Transfer(docHandle, oc.STEPControl_StepModelType.STEPControl_AsIs, "", progress);
+        progress.delete();
+        if (!transferred) {
+            writer.delete();
+            cleanup();
+            throw new Error('STEP XCAF transfer failed');
+        }
+        const writeStatus = writer.Write(fileName);
+        writer.delete();
+        if (writeStatus !== oc.IFSelect_ReturnStatus.IFSelect_RetDone) {
+            cleanup();
+            throw new Error(`STEP XCAF write failed. Status: ${writeStatus}`);
+        }
+        // The XCAF writer may split output into a main file (assembly references)
+        // and external files with actual geometry + colors. Collect all STEP files
+        // from the virtual FS and return the one with color data.
+        const rootFiles = oc.FS.readdir('/');
+        const stepFiles = [];
+        for (const f of rootFiles) {
+            if (f === '.' || f === '..' || (!f.endsWith('.stp') && !f.endsWith('.step'))) {
+                continue;
+            }
+            try {
+                stepFiles.push({ name: f, content: oc.FS.readFile(f, { encoding: "utf8" }) });
+            }
+            catch { /* skip */ }
+        }
+        let file;
+        if (stepFiles.length === 1) {
+            file = stepFiles[0].content;
+        }
+        else {
+            const withColors = stepFiles.find(f => f.content.includes('COLOUR_RGB'));
+            file = withColors?.content
+                ?? stepFiles.sort((a, b) => b.content.length - a.content.length)[0].content;
+        }
+        for (const f of stepFiles) {
+            try {
+                oc.FS.unlink(f.name);
+            }
+            catch { /* ignore */ }
+        }
+        cleanup();
+        return file;
+    }
+    static writeStl(compound, fileName, linearDeflection, angularDeflection) {
+        const oc = getOC();
+        const mesh = new oc.BRepMesh_IncrementalMesh(compound, linearDeflection, false, angularDeflection, true);
+        const writer = new oc.StlAPI_Writer();
+        const progress = new oc.Message_ProgressRange();
+        const ok = writer.Write(compound, fileName, progress);
+        progress.delete();
+        if (!ok) {
+            mesh.delete();
+            writer.delete();
+            throw new Error('STL write failed');
+        }
+        const file = oc.FS.readFile(fileName);
+        oc.FS.unlink(fileName);
+        mesh.delete();
+        writer.delete();
+        return file;
+    }
+    static hexToRgb(hex) {
+        const h = hex.replace('#', '');
+        return [
+            parseInt(h.substring(0, 2), 16) / 255,
+            parseInt(h.substring(2, 4), 16) / 255,
+            parseInt(h.substring(4, 6), 16) / 255,
+        ];
+    }
+    static findFaceColor(face, solidShape, colorTool, shapeTool, oc, surfType, faceColorByHash, solidColorByHash) {
+        const hashColor = faceColorByHash.get(face.HashCode(2147483647));
+        if (hashColor)
+            return hashColor;
+        const color = new oc.Quantity_Color();
+        if (colorTool.GetColor(face, surfType, color)) {
+            const hex = OcIO.rgbToHex(color.Red(), color.Green(), color.Blue());
+            color.delete();
+            return hex;
+        }
+        if (colorTool.GetInstanceColor(face, surfType, color)) {
+            const hex = OcIO.rgbToHex(color.Red(), color.Green(), color.Blue());
+            color.delete();
+            return hex;
+        }
+        const identityLoc = new oc.TopLoc_Location();
+        const unlocatedFace = face.Located(identityLoc, false);
+        if (colorTool.GetColor(unlocatedFace, surfType, color)) {
+            const hex = OcIO.rgbToHex(color.Red(), color.Green(), color.Blue());
+            color.delete();
+            identityLoc.delete();
+            return hex;
+        }
+        identityLoc.delete();
+        const faceLabel = new oc.TDF_Label();
+        if (shapeTool.SearchUsingMap(face, faceLabel, true, true)) {
+            if (colorTool.GetColor(faceLabel, surfType, color)) {
+                const hex = OcIO.rgbToHex(color.Red(), color.Green(), color.Blue());
+                color.delete();
+                return hex;
+            }
+        }
+        color.delete();
+        const solidHash = solidColorByHash.get(solidShape.HashCode(2147483647));
+        if (solidHash)
+            return solidHash;
+        const solidColor = new oc.Quantity_Color();
+        if (colorTool.GetColor(solidShape, surfType, solidColor) ||
+            colorTool.GetInstanceColor(solidShape, surfType, solidColor)) {
+            const hex = OcIO.rgbToHex(solidColor.Red(), solidColor.Green(), solidColor.Blue());
+            solidColor.delete();
+            return hex;
+        }
+        solidColor.delete();
+        return null;
+    }
+    static rgbToHex(r, g, b) {
+        const toHex = (c) => Math.round(c * 255).toString(16).padStart(2, '0');
+        return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+}

package/lib/dist/oc/loft-ops.d.ts

@@ -0,0 +1,5 @@
+import { Solid } from "../common/solid.js";
+import { Wire } from "../common/wire.js";
+export declare class LoftOps {
+    static makeLoft(wires: Wire[]): Solid[];
+}

package/lib/dist/oc/loft-ops.js

@@ -0,0 +1,26 @@
+import { getOC } from "./init.js";
+import { Explorer } from "./explorer.js";
+import { Solid } from "../common/solid.js";
+export class LoftOps {
+    static makeLoft(wires) {
+        const oc = getOC();
+        const thruSections = new oc.BRepOffsetAPI_ThruSections(true, false, 1e-6);
+        for (const wire of wires) {
+            thruSections.AddWire(wire.getShape());
+        }
+        const progress = new oc.Message_ProgressRange();
+        thruSections.Build(progress);
+        progress.delete();
+        if (!thruSections.IsDone()) {
+            thruSections.delete();
+            throw new Error("Loft operation failed.");
+        }
+        const result = thruSections.Shape();
+        thruSections.delete();
+        const solids = Explorer.findShapes(result, Explorer.getOcShapeType("solid"));
+        if (solids.length === 0) {
+            throw new Error("Loft produced no solids.");
+        }
+        return solids.map(s => Solid.fromTopoDSSolid(Explorer.toSolid(s)));
+    }
+}

package/lib/dist/oc/measure.d.ts

@@ -0,0 +1,21 @@
+import type { TopoDS_Shape } from "occjs-wrapper";
+export interface MeasurementEntry {
+    label: string;
+    value: number;
+    unit: 'mm' | 'deg';
+    icon: 'distance' | 'angle' | 'radius';
+    axisBreakdown?: {
+        dx: number;
+        dy: number;
+        dz: number;
+    };
+}
+export interface MeasurementResult {
+    headline: MeasurementEntry;
+    others: MeasurementEntry[];
+    refPointA: [number, number, number];
+    refPointB: [number, number, number];
+}
+export declare class OccMeasure {
+    static compute(shapeA: TopoDS_Shape, typeA: 'face' | 'edge', indexA: number, shapeB: TopoDS_Shape, typeB: 'face' | 'edge', indexB: number): MeasurementResult | null;
+}