Example #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;
            }
        }
Example #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);
                }
            }
        }
        private static List <SolidAnalysisObject> getEastMidtownEnvelopes(List <Envelope> envelopes, List <RhinoBrep> rhinoBreps, List <RhinoExtrusion> rhinoExtrusions, List <MeshElement> meshEnvelopes, Model model, Boolean showDebugGeometry)
        {
            var analysisObjects = new List <SolidAnalysisObject>();

            var up                      = new Vector3(0, 0, 1);
            var cutHeight               = Units.FeetToMeters(150.0);
            var plane                   = new Plane(new Vector3(0, 0, cutHeight), Vector3.ZAxis);
            var envelopesForBlockage    = new List <Envelope>();
            var meshElementsForBlockage = new List <MeshElement>();

            foreach (var envelope in envelopes)
            {
                var bottom = envelope.Elevation;
                var top    = bottom + envelope.Height;

                if (top < cutHeight)
                {
                    continue;
                }

                if (bottom >= cutHeight)
                {
                    // envelope is above the cutoff, use as-is
                    analysisObjects.AddRange(SolidAnalysisObject.MakeFromEnvelopes(new List <Envelope>()
                    {
                        envelope
                    }));
                }
                else
                {
                    envelopesForBlockage.AddRange(GeoUtilities.SliceAtHeight(envelope, cutHeight, showDebugGeometry));
                }
            }

            foreach (var rhinoBrep in rhinoBreps)
            {
                envelopesForBlockage.AddRange(GeoUtilities.SliceAtHeight(rhinoBrep, cutHeight, showDebugGeometry));
            }

            foreach (var rhinoExtrusion in rhinoExtrusions)
            {
                envelopesForBlockage.AddRange(GeoUtilities.SliceAtHeight(rhinoExtrusion, cutHeight, showDebugGeometry));
            }

            foreach (var meshElement in meshEnvelopes)
            {
                var bbox   = new BBox3(GeoUtilities.TransformedVertices(meshElement.Mesh.Vertices, meshElement.Transform));
                var bottom = bbox.Min.Z;
                var top    = bbox.Max.Z;

                if (top < cutHeight)
                {
                    continue;
                }

                if (bottom >= cutHeight)
                {
                    // envelope is above the cutoff, use as-is
                    meshElementsForBlockage.Add(meshElement);
                }
                else
                {
                    envelopesForBlockage.AddRange(GeoUtilities.SliceAtHeight(meshElement, cutHeight, showDebugGeometry));
                }
            }

            analysisObjects.AddRange(SolidAnalysisObject.MakeFromEnvelopes(envelopesForBlockage));
            analysisObjects.AddRange(SolidAnalysisObject.MakeFromMeshElements(meshElementsForBlockage));

            return(analysisObjects);
        }