freeform-modeling-mcp 1.0.26

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

@@ -0,0 +1,377 @@
+import { CopyObjectAttributes } from '../core/core.js';
+import { AddCoord3D, Coord3D, CoordIsEqual3D } from '../geometry/coord3d.js';
+import { RGBColor } from './color.js';
+import { PhongMaterial } from './material.js';
+import { CalculateTriangleNormal, GetMeshType, MeshType } from './meshutils.js';
+
+class ModelFinalizer
+{
+    constructor (params)
+    {
+        this.params = {
+            getDefaultMaterialColor : () => {
+                return new RGBColor (0, 0, 0);
+            }
+        };
+        CopyObjectAttributes (params, this.params);
+        this.defaultMaterialIndex = null;
+    }
+
+    Finalize (model)
+    {
+        this.Reset ();
+
+        this.FinalizeMeshes (model);
+        this.FinalizeMaterials (model);
+        this.FinalizeNodes (model);
+    }
+
+    FinalizeMaterials (model)
+    {
+        if (model.VertexColorCount () === 0) {
+            return;
+        }
+
+        let materialHasVertexColors = new Map ();
+        for (let meshIndex = 0; meshIndex < model.MeshCount (); meshIndex++) {
+            let mesh = model.GetMesh (meshIndex);
+            for (let triangleIndex = 0; triangleIndex < mesh.TriangleCount (); triangleIndex++) {
+                let triangle = mesh.GetTriangle (triangleIndex);
+                let hasVertexColors = triangle.HasVertexColors ();
+                if (!materialHasVertexColors.has (triangle.mat)) {
+                    materialHasVertexColors.set (triangle.mat, hasVertexColors);
+                } else if (!hasVertexColors) {
+                    materialHasVertexColors.set (triangle.mat, false);
+                }
+            }
+        }
+
+        for (let [materialIndex, hasVertexColors] of materialHasVertexColors) {
+            let material = model.GetMaterial (materialIndex);
+            material.vertexColors = hasVertexColors;
+        }
+    }
+
+    FinalizeMeshes (model)
+    {
+        for (let meshIndex = 0; meshIndex < model.MeshCount (); meshIndex++) {
+            let mesh = model.GetMesh (meshIndex);
+            let type = GetMeshType (mesh);
+            if (type === MeshType.Empty) {
+                model.RemoveMesh (meshIndex);
+                meshIndex = meshIndex - 1;
+                continue;
+            }
+            this.FinalizeMesh (model, mesh);
+        }
+    }
+
+    FinalizeMesh (model, mesh)
+    {
+        function CalculateCurveNormals (mesh)
+        {
+            function AddAverageNormal (mesh, triangle, vertexIndex, triangleNormals, vertexToTriangles)
+            {
+                function IsNormalInArray (array, normal)
+                {
+                    for (let i = 0; i < array.length; i++) {
+                        let current = array[i];
+                        if (CoordIsEqual3D (current, normal)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+
+                let averageNormals = [];
+                let neigTriangles = vertexToTriangles.get (vertexIndex);
+                for (let i = 0; i < neigTriangles.length; i++) {
+                    let neigIndex = neigTriangles[i];
+                    let neigTriangle = mesh.GetTriangle (neigIndex);
+                    if (triangle.curve === neigTriangle.curve) {
+                        let triangleNormal = triangleNormals[neigIndex];
+                        if (!IsNormalInArray (averageNormals, triangleNormal)) {
+                            averageNormals.push (triangleNormal);
+                        }
+                    }
+                }
+
+                let averageNormal = new Coord3D (0.0, 0.0, 0.0);
+                for (let i = 0; i < averageNormals.length; i++) {
+                    averageNormal = AddCoord3D (averageNormal, averageNormals[i]);
+                }
+                averageNormal.MultiplyScalar (1.0 / averageNormals.length);
+                averageNormal.Normalize ();
+                return mesh.AddNormal (averageNormal);
+            }
+
+            let triangleNormals = [];
+            let vertexToTriangles = new Map ();
+
+            for (let vertexIndex = 0; vertexIndex < mesh.VertexCount (); vertexIndex++) {
+                vertexToTriangles.set (vertexIndex, []);
+            }
+
+            for (let triangleIndex = 0; triangleIndex < mesh.TriangleCount (); triangleIndex++) {
+                let triangle = mesh.GetTriangle (triangleIndex);
+                let v0 = mesh.GetVertex (triangle.v0);
+                let v1 = mesh.GetVertex (triangle.v1);
+                let v2 = mesh.GetVertex (triangle.v2);
+                let normal = CalculateTriangleNormal (v0, v1, v2);
+                triangleNormals.push (normal);
+                vertexToTriangles.get (triangle.v0).push (triangleIndex);
+                vertexToTriangles.get (triangle.v1).push (triangleIndex);
+                vertexToTriangles.get (triangle.v2).push (triangleIndex);
+            }
+
+            for (let triangleIndex = 0; triangleIndex < mesh.TriangleCount (); triangleIndex++) {
+                let triangle = mesh.GetTriangle (triangleIndex);
+                if (!triangle.HasNormals ()) {
+                    let n0 = AddAverageNormal (mesh, triangle, triangle.v0, triangleNormals, vertexToTriangles);
+                    let n1 = AddAverageNormal (mesh, triangle, triangle.v1, triangleNormals, vertexToTriangles);
+                    let n2 = AddAverageNormal (mesh, triangle, triangle.v2, triangleNormals, vertexToTriangles);
+                    triangle.SetNormals (n0, n1, n2);
+                }
+            }
+        }
+
+        let meshStatus = {
+            calculateCurveNormals : false
+        };
+
+        for (let i = 0; i < mesh.TriangleCount (); i++) {
+            let triangle = mesh.GetTriangle (i);
+            this.FinalizeTriangle (mesh, triangle, meshStatus);
+
+            if (triangle.mat === null) {
+                triangle.mat = this.GetDefaultMaterialIndex (model);
+            }
+        }
+
+        if (meshStatus.calculateCurveNormals) {
+            CalculateCurveNormals (mesh);
+        }
+    }
+
+    FinalizeTriangle (mesh, triangle, meshStatus)
+    {
+        if (!triangle.HasNormals ()) {
+            if (triangle.curve === null || triangle.curve === 0) {
+                let v0 = mesh.GetVertex (triangle.v0);
+                let v1 = mesh.GetVertex (triangle.v1);
+                let v2 = mesh.GetVertex (triangle.v2);
+                let normal = CalculateTriangleNormal (v0, v1, v2);
+                let normalIndex = mesh.AddNormal (normal);
+                triangle.SetNormals (normalIndex, normalIndex, normalIndex);
+            } else {
+                meshStatus.calculateCurveNormals = true;
+            }
+        }
+
+        if (triangle.curve === null) {
+            triangle.curve = 0;
+        }
+    }
+
+    FinalizeNodes (model)
+    {
+        let rootNode = model.GetRootNode ();
+
+        let emptyNodes = [];
+        rootNode.EnumerateChildren ((node) => {
+            if (node.IsEmpty ()) {
+                emptyNodes.push (node);
+            }
+        });
+
+        for (let nodeIndex = 0; nodeIndex < emptyNodes.length; nodeIndex++) {
+            let node = emptyNodes[nodeIndex];
+            let parentNode = node.GetParent ();
+            if (parentNode === null) {
+                continue;
+            }
+            parentNode.RemoveChildNode (node);
+            if (parentNode.IsEmpty ()) {
+                emptyNodes.push (parentNode);
+            }
+        }
+    }
+
+    GetDefaultMaterialIndex (model)
+    {
+        if (this.defaultMaterialIndex === null) {
+            let defaultMaterialColor = this.params.getDefaultMaterialColor ();
+            let defaultMaterial = new PhongMaterial ();
+            defaultMaterial.color = defaultMaterialColor;
+            defaultMaterial.isDefault = true;
+            this.defaultMaterialIndex = model.AddMaterial (defaultMaterial);
+        }
+        return this.defaultMaterialIndex;
+    }
+
+    Reset ()
+    {
+        this.defaultMaterialIndex = null;
+    }
+}
+
+export function FinalizeModel (model, params)
+{
+    let finalizer = new ModelFinalizer (params);
+    finalizer.Finalize (model);
+}
+
+export function CheckModel (model)
+{
+    function IsCorrectValue (val)
+    {
+        if (val === undefined || val === null) {
+            return false;
+        }
+        return true;
+    }
+
+    function IsCorrectNumber (val)
+    {
+        if (!IsCorrectValue (val)) {
+            return false;
+        }
+        if (isNaN (val)) {
+            return false;
+        }
+        return true;
+    }
+
+    function IsCorrectIndex (val, count)
+    {
+        if (!IsCorrectNumber (val)) {
+            return false;
+        }
+        if (val < 0 || val >= count) {
+            return false;
+        }
+        return true;
+    }
+
+    function CheckMesh (model, mesh)
+    {
+        function CheckTriangle (model, mesh, triangle)
+        {
+            if (!IsCorrectIndex (triangle.v0, mesh.VertexCount ())) {
+                return false;
+            }
+            if (!IsCorrectIndex (triangle.v1, mesh.VertexCount ())) {
+                return false;
+            }
+            if (!IsCorrectIndex (triangle.v2, mesh.VertexCount ())) {
+                return false;
+            }
+            if (triangle.HasVertexColors ()) {
+                if (!IsCorrectIndex (triangle.c0, mesh.VertexColorCount ())) {
+                    return false;
+                }
+                if (!IsCorrectIndex (triangle.c1, mesh.VertexColorCount ())) {
+                    return false;
+                }
+                if (!IsCorrectIndex (triangle.c2, mesh.VertexColorCount ())) {
+                    return false;
+                }
+            }
+            if (!IsCorrectIndex (triangle.n0, mesh.NormalCount ())) {
+                return false;
+            }
+            if (!IsCorrectIndex (triangle.n1, mesh.NormalCount ())) {
+                return false;
+            }
+            if (!IsCorrectIndex (triangle.n2, mesh.NormalCount ())) {
+                return false;
+            }
+            if (triangle.HasTextureUVs ()) {
+                if (!IsCorrectIndex (triangle.u0, mesh.TextureUVCount ())) {
+                    return false;
+                }
+                    if (!IsCorrectIndex (triangle.u1, mesh.TextureUVCount ())) {
+                    return false;
+                }
+                if (!IsCorrectIndex (triangle.u2, mesh.TextureUVCount ())) {
+                    return false;
+                }
+            }
+            if (!IsCorrectIndex (triangle.mat, model.MaterialCount ())) {
+                return false;
+            }
+            if (!IsCorrectNumber (triangle.curve)) {
+                return false;
+            }
+
+            return true;
+        }
+
+        for (let i = 0; i < mesh.VertexCount (); i++) {
+            let vertex = mesh.GetVertex (i);
+            if (!IsCorrectNumber (vertex.x)) {
+                return false;
+            }
+            if (!IsCorrectNumber (vertex.y)) {
+                return false;
+            }
+            if (!IsCorrectNumber (vertex.z)) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < mesh.VertexColorCount (); i++) {
+            let color = mesh.GetVertexColor (i);
+            if (!IsCorrectNumber (color.r)) {
+                return false;
+            }
+            if (!IsCorrectNumber (color.g)) {
+                return false;
+            }
+            if (!IsCorrectNumber (color.b)) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < mesh.NormalCount (); i++) {
+            let normal = mesh.GetNormal (i);
+            if (!IsCorrectNumber (normal.x)) {
+                return false;
+            }
+            if (!IsCorrectNumber (normal.y)) {
+                return false;
+            }
+            if (!IsCorrectNumber (normal.z)) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < mesh.TextureUVCount (); i++) {
+            let uv = mesh.GetTextureUV (i);
+            if (!IsCorrectNumber (uv.x)) {
+                return false;
+            }
+            if (!IsCorrectNumber (uv.y)) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < mesh.TriangleCount (); i++) {
+            let triangle = mesh.GetTriangle (i);
+            if (!CheckTriangle (model, mesh, triangle)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    for (let i = 0; i < model.MeshCount (); i++) {
+        let mesh = model.GetMesh (i);
+        if (!CheckMesh (model, mesh)) {
+            return false;
+        }
+    }
+
+    return true;
+}

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

@@ -0,0 +1,117 @@
+import { BoundingBoxCalculator3D } from '../geometry/box3d.js';
+import { Octree } from '../geometry/octree.js';
+import { GetMeshType, MeshType } from './meshutils.js';
+import { Model } from './model.js';
+import { Topology } from './topology.js';
+
+export function IsModelEmpty (model)
+{
+    let isEmpty = true;
+    model.EnumerateMeshInstances ((meshInstance) => {
+        if (GetMeshType (meshInstance) !== MeshType.Empty) {
+            isEmpty = false;
+        }
+    });
+    return isEmpty;
+}
+
+export function GetBoundingBox (object3D)
+{
+    let calculator = new BoundingBoxCalculator3D ();
+    object3D.EnumerateVertices ((vertex) => {
+        calculator.AddPoint (vertex);
+    });
+    return calculator.GetBox ();
+}
+
+export function GetTopology (object3D)
+{
+    function GetVertexIndex (vertex, octree, topology)
+    {
+        let index = octree.FindPoint (vertex);
+        if (index === null) {
+            index = topology.AddVertex ();
+            octree.AddPoint (vertex, index);
+        }
+        return index;
+    }
+
+    let boundingBox = GetBoundingBox (object3D);
+    let octree = new Octree (boundingBox);
+    let topology = new Topology ();
+
+    object3D.EnumerateTriangleVertices ((v0, v1, v2) => {
+        let v0Index = GetVertexIndex (v0, octree, topology);
+        let v1Index = GetVertexIndex (v1, octree, topology);
+        let v2Index = GetVertexIndex (v2, octree, topology);
+        topology.AddTriangle (v0Index, v1Index, v2Index);
+    });
+    return topology;
+}
+
+export function IsTwoManifold (object3D)
+{
+    function GetEdgeOrientationInTriangle (topology, triangleIndex, edgeIndex)
+    {
+        const triangle = topology.triangles[triangleIndex];
+        const triEdge1 = topology.triangleEdges[triangle.triEdge1];
+        const triEdge2 = topology.triangleEdges[triangle.triEdge2];
+        const triEdge3 = topology.triangleEdges[triangle.triEdge3];
+        if (triEdge1.edge === edgeIndex) {
+            return triEdge1.reversed;
+        }
+        if (triEdge2.edge === edgeIndex) {
+            return triEdge2.reversed;
+        }
+        if (triEdge3.edge === edgeIndex) {
+            return triEdge3.reversed;
+        }
+        return null;
+    }
+
+    if (object3D instanceof Model) {
+        let isTwoManifold = true;
+        object3D.EnumerateMeshInstances ((meshInstance) => {
+            if (isTwoManifold) {
+                isTwoManifold = IsTwoManifold (meshInstance);
+            }
+        });
+        return isTwoManifold;
+    } else {
+        const topology = GetTopology (object3D);
+        for (let edgeIndex = 0; edgeIndex < topology.edges.length; edgeIndex++) {
+            const edge = topology.edges[edgeIndex];
+            if (edge.triangles.length !== 2) {
+                return false;
+            }
+
+            let edgeOrientation1 = GetEdgeOrientationInTriangle (topology, edge.triangles[0], edgeIndex);
+            let edgeOrientation2 = GetEdgeOrientationInTriangle (topology, edge.triangles[1], edgeIndex);
+            if (edgeOrientation1 === null || edgeOrientation2 === null || edgeOrientation1 === edgeOrientation2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+export function HasDefaultMaterial (model)
+{
+    for (let i = 0; i < model.MaterialCount (); i++) {
+        let material = model.GetMaterial (i);
+        if (material.isDefault && !material.vertexColors) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export function ReplaceDefaultMaterialColor (model, color)
+{
+    for (let i = 0; i < model.MaterialCount (); i++) {
+        let material = model.GetMaterial (i);
+        if (material.isDefault) {
+            material.color = color;
+        }
+    }
+}

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

@@ -0,0 +1,178 @@
+import { Transformation } from '../geometry/transformation.js';
+
+class NodeIdGenerator
+{
+    constructor ()
+    {
+        this.nextId = 0;
+    }
+
+    GenerateId ()
+    {
+        const id = this.nextId;
+        this.nextId += 1;
+        return id;
+    }
+}
+
+export const NodeType =
+{
+    GroupNode : 0,
+    MeshNode : 1
+};
+
+export class Node
+{
+    constructor ()
+    {
+        this.type = NodeType.GroupNode;
+        this.name = '';
+        this.parent = null;
+        this.transformation = new Transformation ();
+
+        this.childNodes = [];
+        this.meshIndices = [];
+
+        this.idGenerator = new NodeIdGenerator ();
+        this.id = this.idGenerator.GenerateId ();
+    }
+
+    IsEmpty ()
+    {
+        return this.childNodes.length === 0 && this.meshIndices.length === 0;
+    }
+
+    GetType ()
+    {
+        return this.type;
+    }
+
+    SetType (type)
+    {
+        this.type = type;
+    }
+
+    GetId ()
+    {
+        return this.id;
+    }
+
+    GetName ()
+    {
+        return this.name;
+    }
+
+    SetName (name)
+    {
+        this.name = name;
+    }
+
+    HasParent ()
+    {
+        return this.parent !== null;
+    }
+
+    GetParent ()
+    {
+        return this.parent;
+    }
+
+    GetTransformation ()
+    {
+        return this.transformation;
+    }
+
+    GetWorldTransformation ()
+    {
+        let transformation = this.transformation.Clone ();
+        let parent = this.parent;
+        while (parent !== null) {
+            transformation.Append (parent.transformation);
+            parent = parent.parent;
+        }
+        return transformation;
+    }
+
+    SetTransformation (transformation)
+    {
+        this.transformation = transformation;
+    }
+
+    AddChildNode (node)
+    {
+        node.parent = this;
+        node.idGenerator = this.idGenerator;
+        node.id = node.idGenerator.GenerateId ();
+        this.childNodes.push (node);
+        return this.childNodes.length - 1;
+    }
+
+    RemoveChildNode (node)
+    {
+        node.parent = null;
+        let index = this.childNodes.indexOf (node);
+        this.childNodes.splice (index, 1);
+    }
+
+    GetChildNodes ()
+    {
+        return this.childNodes;
+    }
+
+    ChildNodeCount ()
+    {
+        return this.childNodes.length;
+    }
+
+    GetChildNode (index)
+    {
+        return this.childNodes[index];
+    }
+
+    AddMeshIndex (index)
+    {
+        this.meshIndices.push (index);
+        return this.meshIndices.length - 1;
+    }
+
+    MeshIndexCount ()
+    {
+        return this.meshIndices.length;
+    }
+
+    GetMeshIndex (index)
+    {
+        return this.meshIndices[index];
+    }
+
+    GetMeshIndices ()
+    {
+        return this.meshIndices;
+    }
+
+    Enumerate (processor)
+    {
+        processor (this);
+        for (const childNode of this.childNodes) {
+            childNode.Enumerate (processor);
+        }
+    }
+
+    EnumerateChildren (processor)
+    {
+        for (const childNode of this.childNodes) {
+            processor (childNode);
+            childNode.EnumerateChildren (processor);
+        }
+    }
+
+    EnumerateMeshIndices (processor)
+    {
+        for (const meshIndex of this.meshIndices) {
+            processor (meshIndex);
+        }
+        for (const childNode of this.childNodes) {
+            childNode.EnumerateMeshIndices (processor);
+        }
+    }
+}