C# Mesh.get_Triangle方法代码示例

        private void Stream(ArrayList data, Mesh mesh)
        {
            data.Add(new Snoop.Data.ClassSeparator(typeof(Mesh)));

            // TBD: need a MeshTriangleIterator like the other classes, and then we could use Snoop.Data.Enumerable
            data.Add(new Snoop.Data.CategorySeparator("Triangles"));
            data.Add(new Snoop.Data.Int("Number of triangles", mesh.NumTriangles));
            for (int i = 0; i < mesh.NumTriangles; i++)
            {
                data.Add(new Snoop.Data.Object(string.Format("Triangle [{0:d}]", i), mesh.get_Triangle(i)));
            }

            data.Add(new Snoop.Data.CategorySeparator("Vertices"));
            System.Collections.Generic.IList<XYZ> pts = mesh.Vertices;
            int j = 0;
            foreach (XYZ pt in pts)
            {
                data.Add(new Snoop.Data.Xyz(string.Format("PT [{0:d}]", j++), pt));
            }
        }

        public virtual void Stream(Mesh mesh)
        {
            for (int i=0; i<mesh.NumTriangles; i++) {
                MeshTriangle mt = mesh.get_Triangle(i);

                Stream(mt.get_Vertex(0), mt.get_Vertex(1));
                Stream(mt.get_Vertex(1), mt.get_Vertex(2));
                Stream(mt.get_Vertex(2), mt.get_Vertex(0));
            }
        }

        /// <summary>
        /// Checks if the faces can create a closed shell.
        /// </summary>
        /// <remarks>
        /// Limitation: This could let through an edge shared an even number of times greater than 2.
        /// </remarks>
        /// <param name="faceSet">The collection of face handles.</param>
        /// <returns>True if can, false if can't.</returns>
        public static bool CanCreateClosedShell(Mesh mesh)
        {
            int numFaces = mesh.NumTriangles;

            // Do simple checks first.
            if (numFaces < 4)
                return false;

            // Try to match up edges.
            IDictionary<uint, IList<uint>> unmatchedEdges = new Dictionary<uint, IList<uint>>();
            int unmatchedEdgeSz = 0;

            for (int ii = 0; ii < numFaces; ii++)
            {
                MeshTriangle meshTriangle = mesh.get_Triangle(ii);
                for (int jj = 0; jj < 3; jj++)
                {
                    uint pt1 = meshTriangle.get_Index(jj);
                    uint pt2 = meshTriangle.get_Index((jj + 1) % 3);

                    IList<uint> unmatchedEdgesPt2 = null;
                    if (unmatchedEdges.TryGetValue(pt2, out unmatchedEdgesPt2) && unmatchedEdgesPt2.Contains(pt1))
                    {
                        unmatchedEdgesPt2.Remove(pt1);
                        unmatchedEdgeSz--;
                    }
                    else
                    {
                        IList<uint> unmatchedEdgesPt1 = null;
                        if (unmatchedEdges.TryGetValue(pt1, out unmatchedEdgesPt1) && unmatchedEdgesPt1.Contains(pt2))
                        {
                            // An edge with the same orientation exists twice; can't create solid.
                            return false;
                        }

                        if (unmatchedEdgesPt1 == null)
                        {
                            unmatchedEdgesPt1 = new List<uint>();
                            unmatchedEdges[pt1] = unmatchedEdgesPt1;
                        }

                        unmatchedEdgesPt1.Add(pt2);
                        unmatchedEdgeSz++;
                    }
                }
            }

            return (unmatchedEdgeSz == 0);
        }

        /// <summary>
        /// Convert a Revit mesh to a Helix mesh for visualization.
        /// In order to merge mesh vertices, this method uses a dictionary with a string key formed as x:y:z of the point.
        /// This assumes that where vertices are the "same" in the Revit mesh, they will have the same coordinates. This
        /// is NOT a safe strategy to use in other mesh-processing contexts where vertices might have small discrepancies.
        /// </summary>
        /// <param name="rmesh"></param>
        /// <param name="octree"></param>
        /// <param name="node"></param>
        /// <returns></returns>
        private static MeshGeometry3D RevitMeshToHelixMesh(Mesh rmesh, Octree.OctreeSearch.Octree octree, NodeModel node)
        {
            var builder = new MeshBuilder();
            var points = new Point3DCollection();
            var tex = new PointCollection();
            var norms = new Vector3DCollection();
            var tris = new List<int>();

            //A dictionary which will contain a point, a normal, and an index
            //keyed on the location of the point as a hash
            var pointDict = new Dictionary<string, PointData>();
            for (int i = 0; i < rmesh.NumTriangles; ++i)
            {
                var tri = rmesh.get_Triangle(i);
                //calculate the face normal by
                //getting the cross product of two edges
                var a = tri.get_Vertex(0);
                var b = tri.get_Vertex(1);
                var c = tri.get_Vertex(2);
                var e1 = b - a;
                var e2 = c - a;
                var normXYZ = e1.CrossProduct(e2).Normalize();
                var normal = new Vector3D(normXYZ.X, normXYZ.Y, normXYZ.Z);

                for (int j = 0; j < 3; j++)
                {
                    var pt = RevitPointToWindowsPoint(tri.get_Vertex(j));
                    var key = pt.X + ":" + pt.Y + ":" + pt.Z;
                    if (!pointDict.ContainsKey(key))
                    {
                        //if the dictionary doesn't contain the key
                        var pd = new PointData(pt.X,pt.Y,pt.Z);
                        pd.Normals.Add(normal);
                        pd.Index = pointDict.Count;
                        pointDict.Add(key, pd);
                        tris.Add(pd.Index);
                    }
                    else
                    {
                        //add an index to our tris array
                        //add a normal to our internal collection
                        //for post processing
                        var data = pointDict[key];
                        tris.Add(data.Index);
                        data.Normals.Add(normal);
                    }
                }
            }

            var lst = pointDict.ToList();
            lst.ForEach(x => points.Add(x.Value.Position));
            lst.ForEach(x=>octree.AddNode(x.Value.Position.X, x.Value.Position.Y, x.Value.Position.Z, node.GUID.ToString()));
            lst.ForEach(x=>tex.Add(x.Value.Tex));

            //merge the normals
            foreach (var pd in lst)
            {
                var avg = new Vector3D();
                var nList = pd.Value.Normals;
                foreach (var n in nList)
                {
                    avg.X += n.X;
                    avg.Y += n.Y;
                    avg.Z += n.Z;
                }
                avg.X = avg.X / nList.Count;
                avg.Y = avg.Y / nList.Count;
                avg.Z = avg.Z / nList.Count;
                norms.Add(avg);
            }

            builder.Append(points, tris, norms, tex);
            Debug.WriteLine(string.Format("Mesh had {0} faces coming in and {1} faces going out.", rmesh.NumTriangles, builder.TriangleIndices.Count / 3));

            return builder.ToMesh(true);
        }