topologicpy 0.4.38__py3-none-any.whl → 0.4.40__py3-none-any.whl

topologicpy/Cell.py

@@ -453,11 +453,12 @@ class Cell(Topology):
             The compactness of the input cell.
 
         """
+        from topologicpy.Face import Face
         faces = []
         _ = cell.Faces(None, faces)
         area = 0.0
         for aFace in faces:
-            area = area + abs(topologic.FaceUtility.Area(aFace))
+            area = area + abs(Face.Area(aFace))
         volume = abs(topologic.CellUtility.Volume(cell))
         compactness  = 0
         #From https://en.wikipedia.org/wiki/Sphericity

topologicpy/CellComplex.py

@@ -57,6 +57,9 @@ class CellComplex(topologic.CellComplex):
             The created cellcomplex.
 
         """
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+
         if not cells:
             return None
         if not isinstance(cells, list):
@@ -64,23 +67,15 @@ class CellComplex(topologic.CellComplex):
         cells = [x for x in cells if isinstance(x, topologic.Cell)]
         if len(cells) < 1:
             return None
-        cellComplex = topologic.CellComplex.ByCells(cells, tolerance)
-        if not cellComplex:
-            warnings.warn("Warning: Default CellComplex.ByCells method failed. Attempting to Merge the Cells.", UserWarning)
-            result = cells[0]
-            remainder = cells[1:]
-            cluster = topologic.Cluster.ByTopologies(remainder, False)
-            result = result.Merge(cluster, False)
-            if result.Type() != 64: #64 is the type of a CellComplex
-                warnings.warn("Warning: Input Cells do not form a CellComplex", UserWarning)
-                if result.Type() > 64:
-                    returnCellComplexes = []
-                    _ = result.CellComplexes(None, returnCellComplexes)
-                    return returnCellComplexes[0]
-                else:
-                    return None
-        else:
-            return cellComplex
+        elif len(cells) == 1:
+            print("CellComplex.ByCells - Warning: Found only one cell. Returning Cell instead of CellComplex.")
+            return cells[0]        
+        cluster = Cluster.ByTopologies(cells)
+        cellComplex = Cluster.SelfMerge(cluster)
+        if not isinstance(cellComplex, topologic.CellComplex):
+            print("CellComplex.ByCells - Warning: Could not create a CellComplex. Returning Cluster instead of CellComplex.")
+            return cluster
+        return cellComplex
     
     @staticmethod
     def ByCellsCluster(cluster: topologic.Cluster, tolerance: float = 0.0001) -> topologic.CellComplex:

topologicpy/Edge.py

@@ -173,6 +173,7 @@ class Edge():
             The created edge.
 
         """
+        from topologicpy.Vertex import Vertex
         edge = None
         if not isinstance(vertexA, topologic.Vertex):
             return None
@@ -180,7 +181,7 @@ class Edge():
             return None
         if topologic.Topology.IsSame(vertexA, vertexB):
             return None
-        if topologic.VertexUtility.Distance(vertexA, vertexB) < tolerance:
+        if Vertex.Distance(vertexA, vertexB) < tolerance:
             return None
         try:
             edge = topologic.Edge.ByStartVertexEndVertex(vertexA, vertexB)

topologicpy/EnergyModel.py

@@ -334,8 +334,7 @@ class EnergyModel:
                     if osFaceNormal.dot(osSurface.outwardNormal()) < 1e-6:
                         osSurface.setVertices(list(reversed(osFacePoints)))
                     osSurface.setSpace(osSpace)
-                    faceCells = []
-                    _ = topologic.FaceUtility.AdjacentCells(buildingFace, building, faceCells)
+                    faceCells = Topology.AdjacentTopologies(buildingFace, building, topologyType="cell")
                     if len(faceCells) == 1: #Exterior Surfaces
                         osSurface.setOutsideBoundaryCondition("Outdoors")
                         if (math.degrees(math.acos(osSurface.outwardNormal().dot(openstudio.Vector3d(0, 0, 1)))) > 135) or (math.degrees(math.acos(osSurface.outwardNormal().dot(openstudio.Vector3d(0, 0, 1)))) < 45):

topologicpy/Face.py

@@ -364,7 +364,7 @@ class Face(topologic.Face):
                     aFace = topologic.Face.ByExternalBoundary(Topology.RemoveCollinearEdges(aWire, angTolerance))
                 except:
                     aFace = topologic.Face.ByExternalBoundary(Wire.Planarize(Topology.RemoveCollinearEdges(aWire, angTolerance)))
-                anArea = topologic.FaceUtility.Area(aFace)
+                anArea = Face.Area(aFace)
                 faces.append(aFace)
                 areas.append(anArea)
             max_index = areas.index(max(areas))
@@ -691,7 +691,7 @@ class Face(topologic.Face):
         perimeter = 0.0
         for anEdge in edges:
             perimeter = perimeter + abs(topologic.EdgeUtility.Length(anEdge))
-        area = abs(topologic.FaceUtility.Area(face))
+        area = abs(Face.Area(face))
         compactness  = 0
         #From https://en.wikipedia.org/wiki/Compactness_measure_of_a_shape
 
@@ -860,6 +860,8 @@ class Face(topologic.Face):
 
         """
 
+        from topologicpy.Vertex import Vertex
+
         def leftMost(vertices, tolerance = 0.0001):
             xCoords = []
             for v in vertices:
@@ -884,7 +886,7 @@ class Face(topologic.Face):
 
         def vIndex(v, vList, tolerance):
             for i in range(len(vList)):
-                if topologic.VertexUtility.Distance(v, vList[i]) < tolerance:
+                if Vertex.Distance(v, vList[i]) < tolerance:
                     return i+1
             return None
         
@@ -1128,80 +1130,59 @@ class Face(topologic.Face):
             True if the input vertex is inside the input face. False otherwise.
 
         """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        import numpy as np
 
-        # Ray tracing from https://stackoverflow.com/questions/36399381/whats-the-fastest-way-of-checking-if-a-point-is-inside-a-polygon-in-python
-        def ray_tracing_method(x,y,poly):
-            n = len(poly)
-            inside = False
+        def point_inside_face(point, outer_boundary, inner_boundaries):
+            def is_point_inside_polygon(p, polygon):
+                n = len(polygon)
+                inside = False
 
-            p1x,p1y = poly[0]
-            for i in range(n+1):
-                p2x,p2y = poly[i % n]
-                if y > min(p1y,p2y):
-                    if y <= max(p1y,p2y):
-                        if x <= max(p1x,p2x):
-                            if p1y != p2y:
-                                xints = (y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
-                            if p1x == p2x or x <= xints:
-                                inside = not inside
-                p1x,p1y = p2x,p2y
+                x, y, z = p
+                p1x, p1y, p1z = polygon[0]
 
-            return inside
+                for i in range(n + 1):
+                    p2x, p2y, p2z = polygon[i % n]
+                    if y > min(p1y, p2y):
+                        if y <= max(p1y, p2y):
+                            if x <= max(p1x, p2x):
+                                if p1y != p2y:
+                                    xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                                    if x <= xinters:
+                                        inside = not inside
+                    p1x, p1y, p1z = p2x, p2y, p2z
 
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Topology import Topology
-        from topologicpy.Dictionary import Dictionary
+                return inside
+
+            if is_point_inside_polygon(point, outer_boundary):
+                for inner_boundary in inner_boundaries:
+                    if is_point_inside_polygon(point, inner_boundary):
+                        return False
 
+                return True
+
+            return False
+        
         if not isinstance(face, topologic.Face):
             return None
         if not isinstance(vertex, topologic.Vertex):
             return None
 
-        world_origin = Vertex.ByCoordinates(0,0,0)
-        # Flatten face and vertex
-        flatFace = Face.Flatten(face)
-        # Retrieve the needed transformations
-        dictionary = Topology.Dictionary(flatFace)
-        xTran = Dictionary.ValueAtKey(dictionary,"xTran")
-        yTran = Dictionary.ValueAtKey(dictionary,"yTran")
-        zTran = Dictionary.ValueAtKey(dictionary,"zTran")
-        phi = Dictionary.ValueAtKey(dictionary,"phi")
-        theta = Dictionary.ValueAtKey(dictionary,"theta")
-
-        vertex = Topology.Translate(vertex, -xTran, -yTran, -zTran)
-        vertex = Topology.Rotate(vertex, origin=world_origin, x=0, y=0, z=1, degree=-phi)
-        vertex = Topology.Rotate(vertex, origin=world_origin, x=0, y=1, z=0, degree=-theta)
-
-        # Test if Vertex is hovering above or below face
-        if abs(Vertex.Z(vertex)) > tolerance:
+        # Test the distance first
+        if Vertex.Distance(vertex, face, includeCentroid=False) > tolerance:
             return False
-
-        # Build 2D poly from flat face
-        wire = Face.ExternalBoundary(flatFace)
-        vertices = Wire.Vertices(wire)
-        poly = []
-        for v in vertices:
-            poly.append([Vertex.X(v), Vertex.Y(v)])
-
-        # Use ray tracing method to test if vertex is inside the face
-        status = ray_tracing_method(Vertex.X(vertex), Vertex.Y(vertex), poly)
-        # Vertex is not inside
-        if not status:
-            return status
-
-        # If it is inside, we must check if it is inside a hole in the face
-        internal_boundaries = Face.InternalBoundaries(flatFace)
-        if len(internal_boundaries) == 0:
-            return status
         
-        for ib in internal_boundaries:
-            vertices = Wire.Vertices(ib)
-            poly = []
-            for v in vertices:
-                poly.append([Vertex.X(v), Vertex.Y(v)])
-            status2 = ray_tracing_method(Vertex.X(vertex), Vertex.Y(vertex), poly)
-            if status2:
-                return False
+        point = (Vertex.X(vertex), Vertex.Y(vertex), Vertex.Z(vertex))
+        ob = Face.ExternalBoundary(face)
+        ibs = Face.InternalBoundaries(face)
+        outer_boundary = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in Topology.Vertices(ob)]
+        inner_boundaries = []
+        for ib in ibs:
+            inner_boundary = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in Topology.Vertices(ib)]
+            inner_boundaries.append(inner_boundary)
+        status = point_inside_face(point, outer_boundary, inner_boundaries)
         return status
 
     @staticmethod