コード例 #1
0
        private SolidAnalysisObject(MeshElement meshElement)
        {
            Dictionary <string, long> edgeLookup = new Dictionary <string, long>();

            long edgeIdx = 0;

            foreach (var vertex in meshElement.Mesh.Vertices)
            {
                var key   = vertex.Index;
                var point = GeoUtilities.TransformedPoint(vertex.Position, meshElement.Transform);
                this.Points.Add(key, point);
                this._maxVertexKey = Math.Max(this._maxVertexKey, key);
            }

            var tIdx = 0;

            foreach (var triangle in meshElement.Mesh.Triangles)
            {
                var vertices = triangle.Vertices.ToList();
                var edges    = new List <AnalysisEdge>();

                var vIdx = 0;

                // Only add points where face is not sitting on Z = 0
                var pointNotZero = false;

                foreach (var startVertex in vertices)
                {
                    var endVertex = vIdx == vertices.Count - 1 ? vertices[0] : vertices[vIdx + 1];

                    var lowerVertex  = startVertex.Index < endVertex.Index ? startVertex : endVertex;
                    var higherVertex = startVertex.Index > endVertex.Index ? startVertex : endVertex;

                    var lineIdUniq = $"{lowerVertex.Index}_{higherVertex.Index}";

                    pointNotZero = pointNotZero || (this.Points[lowerVertex.Index].Z != 0.0 || this.Points[higherVertex.Index].Z != 0.0);

                    if (!edgeLookup.ContainsKey(lineIdUniq))
                    {
                        this.AddEdge(edgeIdx, lowerVertex.Index, higherVertex.Index);
                        edgeLookup.Add(lineIdUniq, edgeIdx);
                        edgeIdx += 1;
                    }

                    if (edgeLookup.TryGetValue(lineIdUniq, out long addedOrExistingEdgeIdx))
                    {
                        var isReversed = startVertex.Index != lowerVertex.Index;
                        edges.Add(new AnalysisEdge(addedOrExistingEdgeIdx, isReversed));
                    }

                    vIdx += 1;
                }
                if (pointNotZero)
                {
                    this.Surfaces.Add(edges);
                }
                tIdx += 1;
            }
        }
コード例 #2
0
        private SolidAnalysisObject(Elements.Geometry.Solids.SolidOperation solid, Transform transform)
        {
            var solidTransform = solid.LocalTransform;

            foreach (var vertex in solid.Solid.Vertices)
            {
                var key   = vertex.Key;
                var point = vertex.Value.Point;
                var locallyTransformedPoint  = GeoUtilities.TransformedPoint(vertex.Value.Point, solidTransform);
                var globallyTransformedPoint = GeoUtilities.TransformedPoint(locallyTransformedPoint, transform);
                this.Points.Add(key, globallyTransformedPoint);
                this._maxVertexKey = Math.Max(this._maxVertexKey, key);
            }

            foreach (var edge in solid.Solid.Edges)
            {
                this.AddEdge(edge.Key, edge.Value.Left.Vertex.Id, edge.Value.Right.Vertex.Id);
            }

            foreach (var face in solid.Solid.Faces.Values)
            {
                var edges = new List <AnalysisEdge>();
                // Only add points where face is not sitting on Z = 0
                var pointNotZero = false;
                foreach (var edge in face.Outer.Edges)
                {
                    var isReversed = edge.Vertex.Id != edge.Edge.Left.Vertex.Id;
                    edges.Add(new AnalysisEdge(edge.Edge.Id, isReversed));
                    pointNotZero = pointNotZero || this.Points.GetValueOrDefault(edge.Vertex.Id).Z != 0;
                    this.Points.GetValueOrDefault(edge.Edge.Left.Vertex.Id);
                }
                if (pointNotZero)
                {
                    this.Surfaces.Add(edges);
                }
            }
        }