freeform-modeling-mcp 1.0.26

package/src/lib/gltf2obj/engine/model/object.js

@@ -0,0 +1,90 @@
+export class Object3D
+{
+    constructor ()
+    {
+
+    }
+
+    VertexCount ()
+    {
+        return 0;
+    }
+
+    VertexColorCount ()
+    {
+        return 0;
+    }
+
+    NormalCount ()
+    {
+        return 0;
+    }
+
+    TextureUVCount ()
+    {
+        return 0;
+    }
+
+    TriangleCount ()
+    {
+        return 0;
+    }
+
+    EnumerateVertices (onVertex)
+    {
+
+    }
+
+    EnumerateTriangleVertexIndices (onTriangleVertexIndices)
+    {
+
+    }
+
+    EnumerateTriangleVertices (onTriangleVertices)
+    {
+
+    }
+}
+
+export class ModelObject3D extends Object3D
+{
+    constructor ()
+    {
+        super ();
+        this.name = '';
+        this.propertyGroups = [];
+    }
+
+    GetName ()
+    {
+        return this.name;
+    }
+
+    SetName (name)
+    {
+        this.name = name;
+    }
+
+    PropertyGroupCount ()
+    {
+        return this.propertyGroups.length;
+    }
+
+    AddPropertyGroup (propertyGroup)
+    {
+        this.propertyGroups.push (propertyGroup);
+        return this.propertyGroups.length - 1;
+    }
+
+    GetPropertyGroup (index)
+    {
+        return this.propertyGroups[index];
+    }
+
+    CloneProperties (target)
+    {
+        for (let propertyGroup of this.propertyGroups) {
+            target.AddPropertyGroup (propertyGroup.Clone ());
+        }
+    }
+}

package/src/lib/gltf2obj/engine/model/property.js

@@ -0,0 +1,86 @@
+import { EscapeHtmlChars } from '../core/core.js';
+import { RGBColorToHexString } from './color.js';
+
+export const PropertyType =
+{
+    Text : 1,
+    Integer : 2,
+    Number : 3,
+    Boolean : 4,
+    Percent : 5,
+    Color : 6
+};
+
+export class Property
+{
+    constructor (type, name, value)
+    {
+        this.type = type;
+        this.name = name;
+        this.value = value;
+    }
+
+    Clone ()
+    {
+        const clonable = (this.type === PropertyType.Color);
+        if (clonable) {
+            return new Property (this.type, this.name, this.value.Clone ());
+        } else {
+            return new Property (this.type, this.name, this.value);
+        }
+    }
+}
+
+export class PropertyGroup
+{
+    constructor (name)
+    {
+        this.name = name;
+        this.properties = [];
+    }
+
+    PropertyCount ()
+    {
+        return this.properties.length;
+    }
+
+    AddProperty (property)
+    {
+        this.properties.push (property);
+    }
+
+    GetProperty (index)
+    {
+        return this.properties[index];
+    }
+
+    Clone ()
+    {
+        let cloned = new PropertyGroup (this.name);
+        for (let property of this.properties) {
+            cloned.AddProperty (property.Clone ());
+        }
+        return cloned;
+    }
+}
+
+export function PropertyToString (property)
+{
+    if (property.type === PropertyType.Text) {
+        return EscapeHtmlChars (property.value);
+    } else if (property.type === PropertyType.Integer) {
+        return property.value.toLocaleString ();
+    } else if (property.type === PropertyType.Number) {
+        return property.value.toLocaleString (undefined, {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2
+        });
+    } else if (property.type === PropertyType.Boolean) {
+        return property.value ? 'True' : 'False';
+    } else if (property.type === PropertyType.Percent) {
+        return parseInt (property.value * 100, 10).toString () + '%';
+    } else if (property.type === PropertyType.Color) {
+        return '#' + RGBColorToHexString (property.value);
+    }
+    return null;
+}

package/src/lib/gltf2obj/engine/model/quantities.js

@@ -0,0 +1,46 @@
+import { CoordDistance3D, CrossVector3D, DotVector3D } from '../geometry/coord3d.js';
+import { Model } from './model.js';
+
+export function GetTriangleArea (v0, v1, v2)
+{
+    const a = CoordDistance3D (v0, v1);
+    const b = CoordDistance3D (v1, v2);
+    const c = CoordDistance3D (v0, v2);
+    const s = (a + b + c) / 2.0;
+    const areaSquare = s * (s - a) * (s - b) * (s - c);
+    if (areaSquare < 0.0) {
+        return 0.0;
+    }
+    return Math.sqrt (areaSquare);
+}
+
+export function GetTetrahedronSignedVolume (v0, v1, v2)
+{
+    return DotVector3D (v0, CrossVector3D (v1, v2)) / 6.0;
+}
+
+export function CalculateVolume (object3D)
+{
+    if (object3D instanceof Model) {
+        let volume = 0.0;
+        object3D.EnumerateMeshInstances ((meshInstance) => {
+            volume += CalculateVolume (meshInstance);
+        });
+        return volume;
+    } else {
+        let volume = 0.0;
+        object3D.EnumerateTriangleVertices ((v0, v1, v2) => {
+            volume += GetTetrahedronSignedVolume (v0, v1, v2);
+        });
+        return volume;
+    }
+}
+
+export function CalculateSurfaceArea (object3D)
+{
+    let surface = 0.0;
+    object3D.EnumerateTriangleVertices ((v0, v1, v2) => {
+        surface += GetTriangleArea (v0, v1, v2);
+    });
+    return surface;
+}

package/src/lib/gltf2obj/engine/model/topology.js

@@ -0,0 +1,139 @@
+export class TopologyVertex
+{
+    constructor ()
+    {
+        this.edges = [];
+        this.triangles = [];
+    }
+}
+
+export class TopologyEdge
+{
+    constructor (vertex1, vertex2)
+    {
+        this.vertex1 = vertex1;
+        this.vertex2 = vertex2;
+        this.triangles = [];
+    }
+}
+
+export class TopologyTriangleEdge
+{
+    constructor (edge, reversed)
+    {
+        this.edge = edge;
+        this.reversed = reversed;
+    }
+}
+
+export class TopologyTriangle
+{
+    constructor ()
+    {
+        this.triEdge1 = null;
+        this.triEdge2 = null;
+        this.triEdge3 = null;
+    }
+}
+
+export class Topology
+{
+    constructor ()
+    {
+        this.vertices = [];
+        this.edges = [];
+        this.triangleEdges = [];
+        this.triangles = [];
+        this.edgeStartToEndVertexMap = new Map ();
+    }
+
+    AddVertex ()
+    {
+        this.vertices.push (new TopologyVertex ());
+        return this.vertices.length - 1;
+    }
+
+    AddTriangle (vertex1, vertex2, vertex3)
+    {
+        function AddTriangleToVertex (vertices, vertexIndex, triangleIndex)
+        {
+            let vertex = vertices[vertexIndex];
+            vertex.triangles.push (triangleIndex);
+        }
+
+        function AddEdgeToVertex (vertices, triangleEdges, vertexIndex, triangleEdgeIndex)
+        {
+            let vertex = vertices[vertexIndex];
+            let triangleEdge = triangleEdges[triangleEdgeIndex];
+            vertex.edges.push (triangleEdge.edge);
+        }
+
+        function AddTriangleToEdge (edges, triangleEdges, triangleEdgeIndex, triangleIndex)
+        {
+            let triangleEdge = triangleEdges[triangleEdgeIndex];
+            let edge = edges[triangleEdge.edge];
+            edge.triangles.push (triangleIndex);
+        }
+
+        let triangleIndex = this.triangles.length;
+
+        let triangle = new TopologyTriangle ();
+        triangle.triEdge1 = this.AddTriangleEdge (vertex1, vertex2);
+        triangle.triEdge2 = this.AddTriangleEdge (vertex2, vertex3);
+        triangle.triEdge3 = this.AddTriangleEdge (vertex3, vertex1);
+
+        AddTriangleToVertex (this.vertices, vertex1, triangleIndex);
+        AddTriangleToVertex (this.vertices, vertex2, triangleIndex);
+        AddTriangleToVertex (this.vertices, vertex3, triangleIndex);
+
+        AddEdgeToVertex (this.vertices, this.triangleEdges, vertex1, triangle.triEdge1);
+        AddEdgeToVertex (this.vertices, this.triangleEdges, vertex2, triangle.triEdge2);
+        AddEdgeToVertex (this.vertices, this.triangleEdges, vertex3, triangle.triEdge3);
+
+        AddTriangleToEdge (this.edges, this.triangleEdges, triangle.triEdge1, triangleIndex);
+        AddTriangleToEdge (this.edges, this.triangleEdges, triangle.triEdge2, triangleIndex);
+        AddTriangleToEdge (this.edges, this.triangleEdges, triangle.triEdge3, triangleIndex);
+
+        this.triangles.push (triangle);
+    }
+
+    AddTriangleEdge (vertex1, vertex2)
+    {
+        let startVertex = vertex1;
+        let endVertex = vertex2;
+        let reversed = false;
+        if (vertex2 < vertex1) {
+            startVertex = vertex2;
+            endVertex = vertex1;
+            reversed = true;
+        }
+
+        let edgeIndex = this.AddEdge (startVertex, endVertex);
+        this.triangleEdges.push (new TopologyTriangleEdge (edgeIndex, reversed));
+        return this.triangleEdges.length - 1;
+    }
+
+    AddEdge (startVertex, endVertex)
+    {
+        if (!this.edgeStartToEndVertexMap.has (startVertex)) {
+            this.edgeStartToEndVertexMap.set (startVertex, []);
+        }
+
+        let endVertices = this.edgeStartToEndVertexMap.get (startVertex);
+        for (let i = 0; i < endVertices.length; i++) {
+            let endVertexItem = endVertices[i];
+            if (endVertexItem.endVertex === endVertex) {
+                return endVertexItem.edgeIndex;
+            }
+        }
+
+        let edgeIndex = this.edges.length;
+        endVertices.push ({
+            endVertex : endVertex,
+            edgeIndex : edgeIndex
+        });
+
+        this.edges.push (new TopologyEdge (startVertex, endVertex));
+        return edgeIndex;
+    }
+}

package/src/lib/gltf2obj/engine/model/triangle.js

@@ -0,0 +1,99 @@
+export class Triangle
+{
+    constructor (v0, v1, v2)
+    {
+        this.v0 = v0;
+        this.v1 = v1;
+        this.v2 = v2;
+
+        this.c0 = null;
+        this.c1 = null;
+        this.c2 = null;
+
+        this.n0 = null;
+        this.n1 = null;
+        this.n2 = null;
+
+        this.u0 = null;
+        this.u1 = null;
+        this.u2 = null;
+
+        this.mat = null;
+        this.curve = null;
+    }
+
+    HasVertices ()
+    {
+        return this.v0 !== null && this.v1 !== null && this.v2 !== null;
+    }
+
+    HasVertexColors ()
+    {
+        return this.c0 !== null && this.c1 !== null && this.c2 !== null;
+    }
+
+    HasNormals ()
+    {
+        return this.n0 !== null && this.n1 !== null && this.n2 !== null;
+    }
+
+    HasTextureUVs ()
+    {
+        return this.u0 !== null && this.u1 !== null && this.u2 !== null;
+    }
+
+    SetVertices (v0, v1, v2)
+    {
+        this.v0 = v0;
+        this.v1 = v1;
+        this.v2 = v2;
+        return this;
+    }
+
+    SetVertexColors (c0, c1, c2)
+    {
+        this.c0 = c0;
+        this.c1 = c1;
+        this.c2 = c2;
+        return this;
+    }
+
+    SetNormals (n0, n1, n2)
+    {
+        this.n0 = n0;
+        this.n1 = n1;
+        this.n2 = n2;
+        return this;
+    }
+
+    SetTextureUVs (u0, u1, u2)
+    {
+        this.u0 = u0;
+        this.u1 = u1;
+        this.u2 = u2;
+        return this;
+    }
+
+    SetMaterial (mat)
+    {
+        this.mat = mat;
+        return this;
+    }
+
+    SetCurve (curve)
+    {
+        this.curve = curve;
+        return this;
+    }
+
+    Clone ()
+    {
+        let cloned = new Triangle (this.v0, this.v1, this.v2);
+        cloned.SetVertexColors (this.c0, this.c1, this.c2);
+        cloned.SetNormals (this.n0, this.n1, this.n2);
+        cloned.SetTextureUVs (this.u0, this.u1, this.u2);
+        cloned.SetMaterial (this.mat);
+        cloned.SetCurve (this.curve);
+        return cloned;
+    }
+}

package/src/lib/gltf2obj/engine/threejs/threemodelloader.js

@@ -0,0 +1,85 @@
+
+import { Importer } from '../import/importer.js';
+import { RevokeObjectUrl } from '../io/bufferutils.js';
+
+export class ThreeModelLoader {
+    constructor() {
+        this.importer = new Importer();
+        this.inProgress = false;
+        this.defaultMaterial = null;
+        this.objectUrls = null;
+    }
+
+    InProgress() {
+        return this.inProgress;
+    }
+
+    LoadModel(inputFiles, settings, callbacks) {
+        if (this.inProgress) {
+            return;
+        }
+
+        this.inProgress = true;
+        this.RevokeObjectUrls();
+        this.importer.ImportFiles(inputFiles, settings, {
+            onLoadStart: () => {
+                callbacks.onLoadStart();
+            },
+            onFileListProgress: (current, total) => {
+                callbacks.onFileListProgress(current, total);
+            },
+            onFileLoadProgress: (current, total) => {
+                callbacks.onFileLoadProgress(current, total);
+            },
+            onImportStart: () => {
+                callbacks.onImportStart();
+            },
+            onSelectMainFile: (fileNames, selectFile) => {
+                if (!callbacks.onSelectMainFile) {
+                    selectFile(0);
+                } else {
+                    callbacks.onSelectMainFile(fileNames, selectFile);
+                }
+            },
+            onImportSuccess: (importResult) => {
+                callbacks.onVisualizationStart();
+                // let params = new ModelToThreeConversionParams();
+                // let output = new ModelToThreeConversionOutput();
+
+                callbacks.onModelFinished(importResult, undefined);
+
+                // ConvertModelToThreeObject(importResult.model, params, output, {
+                //     onTextureLoaded: () => {
+                //         callbacks.onTextureLoaded();
+                //     },
+                //     onModelLoaded: (threeObject) => {
+                //         callbacks.onModelFinished(importResult, threeObject);
+                //         this.inProgress = false;
+                //     }
+                // });
+            },
+            onImportError: (importError) => {
+                callbacks.onLoadError(importError);
+                this.inProgress = false;
+            }
+        });
+    }
+
+    GetImporter() {
+        return this.importer;
+    }
+
+    GetDefaultMaterial() {
+        return this.defaultMaterial;
+    }
+
+    RevokeObjectUrls() {
+        if (this.objectUrls === null) {
+            return;
+        }
+        for (let objectUrl of this.objectUrls) {
+            RevokeObjectUrl(objectUrl);
+        }
+        this.objectUrls = null;
+    }
+}

package/src/lib/gltf2obj/handler.js

@@ -0,0 +1,63 @@
+import * as OV from './engine/main.js';
+export class ExporterWorker {
+    constructor() {
+        this.settings = new OV.ImportSettings()
+        this.loader = new OV.ThreeModelLoader()
+        this.exporterSettings = new OV.ExporterSettings()
+        this.exporter = new OV.Exporter();
+    }
+    export(req, listeners) {
+        let file_name = req.file_name
+        // this.storage.startExport(req.gid, req.request_id, req.convert_type)
+        let inputFiles = []
+        if (req.urlType == 2) {
+            inputFiles = [new OV.InputFile(file_name, OV.FileSource.File, req.url)]
+        } else {
+            inputFiles = [new OV.InputFile(file_name, OV.FileSource.Url, req.url)]
+        }
+        this.loader.LoadModel(inputFiles, this.settings, {
+            onLoadStart: () => { },
+            onFileListProgress: (current, total) => {
+                // let msg = current + "," + total
+                // this.storage.exportStage(req.gid, "FileListProgress", msg)
+            },
+            onFileLoadProgress: (current, total) => {
+                // let msg = current + "," + total
+                // this.storage.exportStage(req.gid, "FileLoadProgress", msg)
+                if (listeners.onProgress) listeners.onProgress(Math.ceil(current * 100 / total))
+            },
+            onImportStart: () => {
+                // let msg = "Importing model..."
+                // this.storage.exportStage(req.gid, "ImportStart", msg)
+            },
+            onSelectMainFile: (fileNames, selectFile) => {
+
+            },
+            onImportSuccess: (importResult) => {
+            },
+            onModelFinished: (importResult, threeObject) => {
+                // let msg = "Exporting model..."
+                // this.storage.exportStage(req.gid, "ExportStart", msg)
+                let model = importResult.model;
+                this.exporter.Export(model, this.exporterSettings, OV.FileFormat.Text, req.convert_type, {
+                    onError: () => {
+                        // this.storage.executionErr(req.gid, "ExportStart", "")
+                        if (listeners.onError) listeners.onError(new Error("ExportStart"));
+                    },
+                    onSuccess: (files, boundingBox) => {
+                        if (files.length < 1) {
+                            return
+                        }
+                        if (listeners.onSuccess) listeners.onSuccess(files, boundingBox);
+                        // this.storage.executionSuccess(req.gid, req.save_path, Buffer.from(file.GetBufferContent()))
+                    }
+                })
+            },
+            onLoadError: (importError) => {
+                // this.storage.executionErr(req.gid, "importError", importError)
+                if (listeners.onError) listeners.onError(importError);
+            },
+            onVisualizationStart: () => { }
+        })
+    }
+}

package/src/lib/gltf2obj/index.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'crypto';
+import { ExporterWorker } from "./handler.js";
+import { compressArrayBufferFiles } from './compress.js';
+
+
+/**
+ * 将 GLB 文件转换为 OBJ 格式并压缩
+ * @param {string} glbUrl - GLB 文件的 URL
+ * @returns {Promise<{zipBuffer:any,boundingBox:any}>} - 压缩后的文件内容
+ */
+export async function gltf2obj(glbUrl, onProgress) {
+    const data = {};
+    data.file_name = "test.glb";
+    data.convert_type = "obj";
+    data.url = glbUrl;
+    data.gid = randomUUID();
+    data.urlType = 1;
+
+    const {
+        files,
+        boundingBox
+    } = await new Promise((res, rej) => {
+        const exporterWorker = new ExporterWorker();
+        exporterWorker.export(data, {
+            onProgress,
+            onError(error) {
+                rej(error);
+            },
+            onSuccess(files, boundingBox) {
+                res({
+                    files,
+                    boundingBox
+                });
+            }
+        });
+    });
+
+    // 将导出的文件映射为压缩需要的格式
+    const buffer = await compressArrayBufferFiles(
+        files.map(f => ({ name: f.name, content: f.content }))
+    );
+
+    return {
+        zipBuffer: buffer,
+        boundingBox
+    };
+}