topologicpy 0.7.94__py3-none-any.whl → 0.7.96__py3-none-any.whl

topologicpy/Cell.py

@@ -348,8 +348,8 @@ class Cell():
         bottomEdges = Topology.Edges(bottomFace)
         for bottomEdge in bottomEdges:
             topEdge = Topology.Translate(bottomEdge, faceNormal[0]*thickness, faceNormal[1]*thickness, faceNormal[2]*thickness)
-            sideEdge1 = Edge.ByVertices([bottomEdge.StartVertex(), topEdge.StartVertex()], tolerance=tolerance, silent=True)
-            sideEdge2 = Edge.ByVertices([bottomEdge.EndVertex(), topEdge.EndVertex()], tolerance=tolerance, silent=True)
+            sideEdge1 = Edge.ByVertices([Edge.StartVertex(bottomEdge), Edge.StartVertex(topEdge)], tolerance=tolerance, silent=True)
+            sideEdge2 = Edge.ByVertices([Edge.EndVertex(bottomEdge), Edge.EndVertex(topEdge)], tolerance=tolerance, silent=True)
             cellWire = Topology.SelfMerge(Cluster.ByTopologies([bottomEdge, sideEdge1, topEdge, sideEdge2]), tolerance=tolerance)
             cellFaces.append(Face.ByWire(cellWire, tolerance=tolerance))
         return Cell.ByFaces(cellFaces, planarize=planarize, tolerance=tolerance)
@@ -485,23 +485,23 @@ class Cell():
                     e3 = None
                     e4 = None
                     try:
-                        e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=True)
+                        e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=True)
                     except:
                         try:
-                            e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=True)
+                            e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=True)
                             faces.append(Face.ByWire(Wire.ByEdges([e1, e2, e4], tolerance=tolerance), tolerance=tolerance))
                         except:
                             pass
                     try:
-                        e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=True)
+                        e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=True)
                     except:
                         try:
-                            e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=True)
+                            e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=True)
                             faces.append(Face.ByWire(Wire.ByEdges([e1, e2, e3], tolerance=tolerance), tolerance=tolerance))
                         except:
                             pass
                     if e3 and e4:
-                        e5 = Edge.ByVertices([e1.StartVertex(), e2.EndVertex()], tolerance=tolerance, silent=True)
+                        e5 = Edge.ByVertices([Edge.StartVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=True)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e5, e4], tolerance=tolerance), tolerance=tolerance))
                         faces.append(Face.ByWire(Wire.ByEdges([e2, e5, e3], tolerance=tolerance), tolerance=tolerance))
             else:
@@ -511,17 +511,17 @@ class Cell():
                     e3 = None
                     e4 = None
                     try:
-                        e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=True)
+                        e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=True)
                     except:
                         try:
-                            e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=True)
+                            e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=True)
                         except:
                             pass
                     try:
-                        e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=True)
+                        e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=True)
                     except:
                         try:
-                            e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=True)
+                            e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=True)
                         except:
                             pass
                     if e3 and e4:
@@ -764,8 +764,8 @@ class Cell():
             yOffset = max(baseRadius, topRadius)
             zOffset = 0
 
-        baseZ = origin.Z() + zOffset
-        topZ = origin.Z() + zOffset + height
+        baseZ = Vertex.Z(origin) + zOffset
+        topZ = Vertex.Z(origin) + zOffset + height
         baseV = []
         topV = []
         for i in range(uSides):
@@ -913,7 +913,7 @@ class Cell():
             baseY = Vertex.Y(origin, mantissa=mantissa) + yOffset
             size = radius*3
             for i in range(1, vSides):
-                baseZ = origin.Z() + zOffset + float(height)/float(vSides)*i
+                baseZ = Vertex.Z(origin) + zOffset + float(height)/float(vSides)*i
                 tool_origin = Vertex.ByCoordinates(baseX, baseY, baseZ)
                 cutting_planes.append(Face.ByWire(Wire.Rectangle(origin=tool_origin, width=size, length=size), tolerance=tolerance))
             cutting_planes_cluster = Cluster.ByTopologies(cutting_planes)
@@ -950,6 +950,7 @@ class Cell():
             8. "inclinedApertures": list of inclined apertures
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Face import Face
         from topologicpy.Vector import Vector
         from topologicpy.Aperture import Aperture
@@ -986,7 +987,7 @@ class Cell():
         faces = Cell.Faces(cell)
         zList = []
         for f in faces:
-            zList.append(f.Centroid().Z())
+            zList.append(Vertex.Z(Topology.Centroid(f)))
         zMin = min(zList)
         zMax = max(zList)
         up = [0, 0, 1]
@@ -997,14 +998,14 @@ class Cell():
                 verticalFaces.append(aFace)
                 verticalApertures += getApertures(aFace)
             elif aCode == 1:
-                if abs(aFace.Centroid().Z() - zMin) < tolerance:
+                if abs(Vertex.Z(Topology.Centroid(aFace)) - zMin) < tolerance:
                     bottomHorizontalFaces.append(aFace)
                     bottomHorizontalApertures += getApertures(aFace)
                 else:
                     topHorizontalFaces.append(aFace)
                     topHorizontalApertures += getApertures(aFace)
             elif aCode == 2:
-                if abs(aFace.Centroid().Z() - zMax) < tolerance:
+                if abs(Vertex.Z(Topology.Centroid(aFace)) - zMax) < tolerance:
                     topHorizontalFaces.append(aFace)
                     topHorizontalApertures += getApertures(aFace)
                 else:
@@ -1344,8 +1345,8 @@ class Cell():
         elif placement.lower() == "lowerleft":
             xOffset = max(baseRadius, topRadius)
             yOffset = max(baseRadius, topRadius)
-        baseZ = w_origin.Z() + zOffset
-        topZ = w_origin.Z() + zOffset + height
+        baseZ = Vertex.Z(w_origin) + zOffset
+        topZ = Vertex.Z(w_origin) + zOffset + height
         for i in range(sides):
             angle = math.radians(360/sides)*i
             if baseRadius > 0:
@@ -1789,8 +1790,8 @@ class Cell():
         topV = []
 
         if Topology.IsInstance(profile, "Wire"):
-            baseWire = Topology.Translate(profile, 0 , 0, sv.Z())
-            topWire = Topology.Translate(profile, 0 , 0, sv.Z()+dist)
+            baseWire = Topology.Translate(profile, 0 , 0, Vertex.Z(sv))
+            topWire = Topology.Translate(profile, 0 , 0, Vertex.Z(sv)+dist)
         else:
             for i in range(sides):
                 angle = math.radians(360/sides)*i
@@ -1813,13 +1814,13 @@ class Cell():
         pipe = Topology.Rotate(pipe, origin=sv, axis=[0, 0, 1], angle=phi)
         zzz = Vertex.ByCoordinates(0, 0, 0)
         if endcapA:
-            origin = edge.StartVertex()
+            origin = Edge.StartVertex(edge)
             x1 = Vertex.X(origin, mantissa=mantissa)
             y1 = Vertex.Y(origin, mantissa=mantissa)
             z1 = Vertex.Z(origin, mantissa=mantissa)
-            x2 = Vertex.X(edge.EndVertex(), mantissa=mantissa)
-            y2 = Vertex.Y(edge.EndVertex(), mantissa=mantissa)
-            z2 = Vertex.Z(edge.EndVertex(), mantissa=mantissa)
+            x2 = Vertex.X(Edge.EndVertex(edge), mantissa=mantissa)
+            y2 = Vertex.Y(Edge.EndVertex(edge), mantissa=mantissa)
+            z2 = Vertex.Z(Edge.EndVertex(edge), mantissa=mantissa)
             dx = x2 - x1
             dy = y2 - y1
             dz = z2 - z1    
@@ -1834,13 +1835,13 @@ class Cell():
             endcapA = Topology.Rotate(endcapA, origin=zzz, axis=[0, 0, 1], angle=phi+180)
             endcapA = Topology.Translate(endcapA, Vertex.X(origin, mantissa=mantissa), Vertex.Y(origin, mantissa=mantissa), Vertex.Z(origin, mantissa=mantissa))
         if endcapB:
-            origin = edge.EndVertex()
+            origin = Edge.EndVertex(edge)
             x1 = Vertex.X(origin, mantissa=mantissa)
             y1 = Vertex.Y(origin, mantissa=mantissa)
             z1 = Vertex.Z(origin, mantissa=mantissa)
-            x2 = Vertex.X(edge.StartVertex(), mantissa=mantissa)
-            y2 = Vertex.Y(edge.StartVertex(), mantissa=mantissa)
-            z2 = Vertex.Z(edge.StartVertex(), mantissa=mantissa)
+            x2 = Vertex.X(Edge.StartVertex(edge), mantissa=mantissa)
+            y2 = Vertex.Y(Edge.StartVertex(edge), mantissa=mantissa)
+            z2 = Vertex.Z(Edge.StartVertex(edge), mantissa=mantissa)
             dx = x2 - x1
             dy = y2 - y1
             dz = z2 - z1    

topologicpy/CellComplex.py

@@ -350,10 +350,10 @@ class CellComplex():
                 e3 = None
                 e4 = None
                 try:
-                    e3 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.StartVertex(), tolerance=tolerance, silent=True)
+                    e3 = Edge.ByStartVertexEndVertex(Edge.StartVertex(e1), Edge.StartVertex(e2), tolerance=tolerance, silent=True)
                 except:
                     try:
-                        e4 = Edge.ByStartVertexEndVertex(e1.EndVertex(), e2.EndVertex(), tolerance=tolerance, silent=True)
+                        e4 = Edge.ByStartVertexEndVertex(Edge.EndVertex(e1), Edge.EndVertex(e2), tolerance=tolerance, silent=True)
                         f = Face.ByExternalBoundary(Wire.ByEdges([e1, e2, e4], tolerance=tolerance))
                         if triangulate == True:
                             if len(Topology.Vertices(face)) > 3:
@@ -366,10 +366,10 @@ class CellComplex():
                     except:
                         pass
                 try:
-                    e4 = Edge.ByStartVertexEndVertex(e1.EndVertex(), e2.EndVertex(), tolerance=tolerance, silent=True)
+                    e4 = Edge.ByStartVertexEndVertex(Edge.EndVertex(e1), Edge.EndVertex(e2), tolerance=tolerance, silent=True)
                 except:
                     try:
-                        e3 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.StartVertex(), tolerance=tolerance, silent=True)
+                        e3 = Edge.ByStartVertexEndVertex(Edge.StartVertex(e1), Edge.StartVertex(e2), tolerance=tolerance, silent=True)
                         f = Face.ByWire(Wire.ByEdges([e1, e2, e3], tolerance=tolerance), tolerance=tolerance)
                         if triangulate == True:
                             if len(Topology.Vertices(face)) > 3:
@@ -383,7 +383,7 @@ class CellComplex():
                         pass
                 if e3 and e4:
                     if triangulate == True:
-                        e5 = Edge.ByStartVertexEndVertex(e1.StartVertex(), e2.EndVertex(), tolerance=tolerance, silent=True)
+                        e5 = Edge.ByStartVertexEndVertex(Edge.StartVertex(e1), Edge.EndVertex(e2), tolerance=tolerance, silent=True)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e5, e4], tolerance=tolerance), tolerance=tolerance))
                         faces.append(Face.ByWire(Wire.ByEdges([e2, e5, e3], tolerance=tolerance), tolerance=tolerance))
                     else:
@@ -485,6 +485,7 @@ class CellComplex():
             15. "internalInclinedApertures": list of internal inclined apertures
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Face import Face
         from topologicpy.Vector import Vector
         from topologicpy.Aperture import Aperture
@@ -527,7 +528,7 @@ class CellComplex():
         faces = CellComplex.Faces(cellComplex)
         zList = []
         for f in faces:
-            zList.append(f.Centroid().Z())
+            zList.append(Vertex.Z(Topology.Centroid(f)))
         zMin = min(zList)
         zMax = max(zList)
         up = [0, 0, 1]
@@ -545,7 +546,7 @@ class CellComplex():
                     internalVerticalApertures += getApertures(aFace)
             elif aCode == 1:
                 if n == 1:
-                    if abs(aFace.Centroid().Z() - zMin) < tolerance:
+                    if abs(Vertex.Z(Topology.Centroid(aFace)) - zMin) < tolerance:
                         bottomHorizontalFaces.append(aFace)
                         bottomHorizontalApertures += getApertures(aFace)
                     else:
@@ -556,7 +557,7 @@ class CellComplex():
                     internalHorizontalApertures += getApertures(aFace)
             elif aCode == 2:
                 if n == 1:
-                    if abs(aFace.Centroid().Z() - zMax) < tolerance:
+                    if abs(Vertex.Z(Topology.Centroid(aFace)) - zMax) < tolerance:
                         topHorizontalFaces.append(aFace)
                         topHorizontalApertures += getApertures(aFace)
                     else:

topologicpy/DGL.py

@@ -1633,6 +1633,7 @@ class DGL:
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Graph import Graph
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
@@ -1661,8 +1662,8 @@ class DGL:
 
         for i in range(len(edges)):
             e = edges[i]
-            sv = e.StartVertex()
-            ev = e.EndVertex()
+            sv = Edge.StartVertex(e)
+            ev = Edge.EndVertex(e)
             sn = nodes[Vertex.Index(vertex=sv, vertices=vertices, strict=False, tolerance=tolerance)]
             en = nodes[Vertex.Index(vertex=ev, vertices=vertices, strict=False, tolerance=tolerance)]
             if (([sn,en] in graph_edges) == False) and (([en,sn] in graph_edges) == False):

topologicpy/Edge.py

@@ -427,8 +427,8 @@ class Edge():
         if not Topology.IsInstance(edge, "Edge"):
             print("Edge.Direction - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
-        ev = edge.EndVertex()
-        sv = edge.StartVertex()
+        sv = Edge.StartVertex(edge)
+        ev = Edge.EndVertex(edge)
         x = Vertex.X(ev, mantissa=mantissa) - Vertex.X(sv, mantissa=mantissa)
         y = Vertex.Y(ev, mantissa=mantissa) - Vertex.Y(sv, mantissa=mantissa)
         z = Vertex.Z(ev, mantissa=mantissa) - Vertex.Z(sv, mantissa=mantissa)
@@ -461,7 +461,7 @@ class Edge():
             return None
         vert = None
         try:
-            vert = edge.EndVertex()
+            vert = edge.EndVertex() # Hook to core
         except:
             vert = None
         return vert
@@ -1247,11 +1247,11 @@ class Edge():
             print("Edge.Normalize - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
         if not useEndVertex:
-            sv = edge.StartVertex()
-            ev = Edge.VertexByDistance(edge, 1.0, edge.StartVertex())
+            sv = Edge.StartVertex(edge)
+            ev = Edge.VertexByDistance(edge, 1.0, Edge.StartVertex(edge))
         else:
-            sv = Edge.VertexByDistance(edge, 1.0, edge.StartVertex())
-            ev = edge.EndVertex()
+            sv = Edge.VertexByDistance(edge, 1.0, Edge.StartVertex(edge))
+            ev = Edge.EndVertex(edge)
         return Edge.ByVertices([sv, ev], tolerance=tolerance)
 
     @staticmethod
@@ -1316,7 +1316,7 @@ class Edge():
         if not Topology.IsInstance(edge, "Edge"):
             print("Edge.Reverse - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
-        return Edge.ByVertices([edge.EndVertex(), edge.StartVertex()], tolerance=tolerance)
+        return Edge.ByVertices([Edge.EndVertex(edge), Edge.StartVertex(edge)], tolerance=tolerance)
     
     @staticmethod
     def SetLength(edge , length: float = 1.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001):
@@ -1375,7 +1375,7 @@ class Edge():
             return None
         vert = None
         try:
-            vert = edge.StartVertex()
+            vert = edge.StartVertex() # Hook to core
         except:
             vert = None
         return vert
@@ -1534,12 +1534,12 @@ class Edge():
             print("Edge.TrimByEdge2D - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
         if not Topology.IsInstance(origin, "Vertex"):
-            origin = edge.StartVertex()
+            origin = Edge.StartVertex(edge)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Edge.TrimByEdge2D - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        sv = edge.StartVertex()
-        ev = edge.EndVertex()
+        sv = Edge.StartVertex(edge)
+        ev = Edge.EndVertex(edge)
         vx = Vertex.X(ev, mantissa=mantissa) - Vertex.X(sv, mantissa=mantissa)
         vy = Vertex.Y(ev, mantissa=mantissa) - Vertex.Y(sv, mantissa=mantissa)
         vz = Vertex.Z(ev, mantissa=mantissa) - Vertex.Z(sv, mantissa=mantissa)
@@ -1572,9 +1572,9 @@ class Edge():
             return None
         vertex = None
         if u == 0:
-            vertex = edge.StartVertex()
+            vertex = Edge.StartVertex(edge)
         elif u == 1:
-            vertex = edge.EndVertex()
+            vertex = Edge.EndVertex(edge)
         else:
             dir = Edge.Direction(edge)
             edge_length = Edge.Length(edge)

topologicpy/EnergyModel.py

@@ -307,7 +307,7 @@ class EnergyModel:
             building_cells = [building]
         for spaceNumber, buildingCell in enumerate(building_cells):
             osSpace = openstudio.model.Space(osModel)
-            osSpaceZ = Vertex.Z(buildingCell.CenterOfMass(), mantissa=mantissa)
+            osSpaceZ = Vertex.Z(Topology.CenterOfMass(buildingCell), mantissa=mantissa)
             osBuildingStory = osBuildingStorys[0]
             for x in osBuildingStorys:
                 osBuildingStoryZ = x.nominalZCoordinate().get()
@@ -372,7 +372,7 @@ class EnergyModel:
                             osSurface.setSurfaceType("RoofCeiling")
                             osSurface.setOutsideBoundaryCondition("Outdoors")
                             osSurface.setName(osSpace.name().get() + "_TopHorizontalSlab_" + str(faceNumber))
-                            if max(list(map(lambda vertex: vertex.Z(), Topology.SubTopologies(buildingFace, "Vertex")))) < 1e-6:
+                            if max(list(map(lambda vertex: Vertex.Z(vertex), Topology.SubTopologies(buildingFace, "Vertex")))) < 1e-6:
                                 osSurface.setSurfaceType("Floor")
                                 osSurface.setOutsideBoundaryCondition("Ground")
                                 osSurface.setName(osSpace.name().get() + "_BottomHorizontalSlab_" + str(faceNumber))
@@ -1039,14 +1039,14 @@ class EnergyModel:
             surfaceEdges = []
             surfaceVertices = surface.vertices()
             for i in range(len(surfaceVertices)-1):
-                sv = Vertex.ByCoordinates(surfaceVertices[i].x(), surfaceVertices[i].y(), surfaceVertices[i].z())
-                ev = Vertex.ByCoordinates(surfaceVertices[i+1].x(), surfaceVertices[i+1].y(), surfaceVertices[i+1].z())
+                sv = Vertex.ByCoordinates(Vertex.X(surfaceVertices[i]), Vertex.Y(surfaceVertices[i]), Vertex.Z(surfaceVertices[i]))
+                ev = Vertex.ByCoordinates(Vertex.X(surfaceVertices[i+1]), Vertex.Y(surfaceVertices[i+1]), Vertex.Z(surfaceVertices[i+1]))
                 edge = Edge.ByStartVertexEndVertex(sv, ev, tolerance=tolerance, silent=False)
                 if not edge:
                     continue
                 surfaceEdges.append(edge)
-            sv = Vertex.ByCoordinates(surfaceVertices[len(surfaceVertices)-1].x(), surfaceVertices[len(surfaceVertices)-1].y(), surfaceVertices[len(surfaceVertices)-1].z())
-            ev = Vertex.ByCoordinates(surfaceVertices[0].x(), surfaceVertices[0].y(), surfaceVertices[0].z())
+            sv = Vertex.ByCoordinates(Vertex.X(surfaceVertices[len(surfaceVertices)-1]), Vertex.Y(surfaceVertices[len(surfaceVertices)-1]), Vertex.Z(surfaceVertices[len(surfaceVertices)-1]))
+            ev = Vertex.ByCoordinates(Vertex.X(surfaceVertices[0]), Vertex.Y(surfaceVertices[0]), Vertex.Z(surfaceVertices[0]))
             edge = Edge.ByStartVertexEndVertex(sv, ev, tolerance=tolerance, silent=False)
             surfaceEdges.append(edge)
             surfaceWire = Wire.ByEdges(surfaceEdges, tolerance=tolerance)
@@ -1057,7 +1057,7 @@ class EnergyModel:
         def addApertures(face, apertures):
             usedFaces = []
             for aperture in apertures:
-                cen = aperture.CenterOfMass()
+                cen = Topology.CenterOfMass(aperture)
                 try:
                     params = face.ParametersAtVertex(cen)
                     u = params[0]

topologicpy/Graph.py

@@ -751,7 +751,7 @@ class Graph:
         return paths
 
     @staticmethod
-    def AreIsomorphic(graphA, graphB, maxIterations=10, silent=False):
+    def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
         Tests if the two input graphs are isomorphic according to the Weisfeiler Lehman graph isomorphism test. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
         
@@ -827,19 +827,19 @@ class Graph:
         
         if not Topology.IsInstance(graphA, "Graph") and not Topology.IsInstance(graphB, "Graph"):
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
             return None
         if not Topology.IsInstance(graphA, "Graph"):
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(graphB, "Graph"):
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
             return None
         if maxIterations <= 0:
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
             return None
         
         g1 = Graph.AdjacencyDictionary(graphA)
@@ -4517,37 +4517,39 @@ class Graph:
         import warnings
         
         try:
-            import community as community_louvain
+            import igraph as ig
         except:
-            print("Graph.Community - Installing required pyhon-louvain library.")
+            print("Graph.Community - Installing required pyhon-igraph library.")
             try:
-                os.system("pip install python-louvain")
+                os.system("pip install python-igraph")
             except:
-                os.system("pip install python-louvain --user")
+                os.system("pip install python-igraph --user")
             try:
-                import community as community_louvain
-                print("Graph.Community - python-louvain library installed correctly.")
+                import igraph as ig
+                print("Graph.Community - python-igraph library installed correctly.")
             except:
-                warnings.warn("Graph.Community - Error: Could not import python-louvain. Please install manually.")
+                warnings.warn("Graph.Community - Error: Could not import python-igraph. Please install manually.")
         
         if not Topology.IsInstance(graph, "graph"):
             if not silent:
                 print("Graph.Community - Error: The input graph parameter is not a valid topologic graph. Returning None")
             return None
         
+        mesh_data = Graph.MeshData(graph)
+        # Create an igraph graph from the edge list
+        ig_graph = ig.Graph(edges=mesh_data['edges'])
+
+        # Detect communities using Louvain method
+        communities = ig_graph.community_multilevel()
+
+        # Get the list of communities sorted same as vertices
+        community_list = communities.membership
         vertices = Graph.Vertices(graph)
-        nx_graph = Graph.NetworkXGraph(graph, mantissa=mantissa, tolerance=tolerance)
-        # Apply the Louvain algorithm
-        partition = community_louvain.best_partition(nx_graph)
-        communities = []
-        # Add the partition value to each node's properties
-        for node, community_id in partition.items():
-            nx_graph.nodes[node][key] = community_id
-            d = Topology.Dictionary(vertices[node])
-            d = Dictionary.SetValueAtKey(d, key, community_id)
-            vertices[node] = Topology.SetDictionary(vertices[node], d)
-            communities.append(community_id)
-        return communities
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, community_list[i])
+            v = Topology.SetDictionary(v, d)
+        return community_list
 
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
@@ -8102,6 +8104,7 @@ class Graph:
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
@@ -8116,8 +8119,8 @@ class Graph:
         m_edges = []
         e_dicts = []
         for g_edge in g_edges:
-            sv = g_edge.StartVertex()
-            ev = g_edge.EndVertex()
+            sv = Edge.StartVertex(g_edge)
+            ev = Edge.EndVertex(g_edge)
             si = Vertex.Index(sv, g_vertices, tolerance=tolerance)
             ei = Vertex.Index(ev, g_vertices, tolerance=tolerance)
             if (not si == None) and (not ei == None):

topologicpy/Honeybee.py

@@ -255,7 +255,7 @@ class Honeybee:
 
         def cellFloor(cell):
             faces = Topology.Faces(cell)
-            c = [x.CenterOfMass().Z() for x in faces]
+            c = [Vertex.Z(Topology.CenterOfMass(x)) for x in faces]
             return round(min(c),2)
 
         def floorLevels(cells, min_difference):

topologicpy/Neo4j.py

@@ -413,6 +413,7 @@ class Neo4j:
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Graph import Graph
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -458,8 +459,8 @@ class Neo4j:
             nodes.append(n)
         for i in range(len(edges)):
             e = edges[i]
-            sv = e.StartVertex()
-            ev = e.EndVertex()
+            sv = Edge.StartVertex(e)
+            ev = Edge.EndVertex(e)
             sn = nodes[Vertex.Index(vertex=sv, vertices=vertices, strict=False, tolerance=tolerance)]
             en = nodes[Vertex.Index(vertex=ev, vertices=vertices, strict=False, tolerance=tolerance)]
             ed = Topology.Dictionary(e)

topologicpy/Shell.py

@@ -432,17 +432,17 @@ class Shell():
                     e3 = None
                     e4 = None
                     try:
-                        e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=silent)
+                        e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=silent)
                     except:
-                        e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=silent)
+                        e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=silent)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e2, e4], tolerance=tolerance), tolerance=tolerance))
                     try:
-                        e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=silent)
+                        e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=silent)
                     except:
-                        e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=silent)
+                        e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=silent)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e2, e3],tolerance=tolerance), tolerance=tolerance))
                     if e3 and e4:
-                        e5 = Edge.ByVertices([e1.StartVertex(), e2.EndVertex()], tolerance=tolerance, silent=silent)
+                        e5 = Edge.ByVertices([Edge.StartVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=silent)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e5, e4], tolerance=tolerance), tolerance=tolerance))
                         faces.append(Face.ByWire(Wire.ByEdges([e2, e5, e3], tolerance=tolerance), tolerance=tolerance))
                     elif e3:
@@ -470,17 +470,17 @@ class Shell():
                     e3 = None
                     e4 = None
                     try:
-                        e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=silent)
+                        e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=silent)
                     except:
                         try:
-                            e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=silent)
+                            e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=silent)
                         except:
                             pass
                     try:
-                        e4 = Edge.ByVertices([e1.EndVertex(), e2.EndVertex()], tolerance=tolerance, silent=silent)
+                        e4 = Edge.ByVertices([Edge.EndVertex(e1), Edge.EndVertex(e2)], tolerance=tolerance, silent=silent)
                     except:
                         try:
-                            e3 = Edge.ByVertices([e1.StartVertex(), e2.StartVertex()], tolerance=tolerance, silent=silent)
+                            e3 = Edge.ByVertices([Edge.StartVertex(e1), Edge.StartVertex(e2)], tolerance=tolerance, silent=silent)
                         except:
                             pass
                     if e3 and e4:

topologicpy/Topology.py

@@ -4145,7 +4145,7 @@ class Topology():
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.CenterofMass - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
-        return topology.CenterOfMass()
+        return topology.CenterOfMass() # Hook to Core
     
     @staticmethod
     def Centroid(topology):
@@ -4169,8 +4169,8 @@ class Topology():
             print("Topology.Centroid - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
         if Topology.IsInstance(topology, "Aperture"):
-            return Aperture.Topology(topology).Centroid()
-        return topology.Centroid()
+            return Aperture.Topology(topology).Centroid() # Hook to Core
+        return topology.Centroid() # Hook to Core
 
     @staticmethod
     def ClusterByKeys(topologies, *keys, silent=False):
@@ -6140,6 +6140,7 @@ class Topology():
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Face import Face
 
         vertices = []
@@ -6164,8 +6165,8 @@ class Topology():
             topEdges = Topology.Edges(topology)
         for anEdge in topEdges:
             e = []
-            sv = anEdge.StartVertex()
-            ev = anEdge.EndVertex()
+            sv = Edge.StartVertex(anEdge)
+            ev = Edge.EndVertex(anEdge)
             try:
                 svIndex = vertices.index(Vertex.Coordinates(sv, mantissa=mantissa))
             except:

topologicpy/Vertex.py

@@ -1728,11 +1728,13 @@ class Vertex():
             The X coordinate of the input vertex.
 
         """
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(vertex, "Vertex"):
-            return None
-        return round(vertex.X(), mantissa)
+        try:
+            return round(vertex.X(), mantissa) # Hook to Core
+        except:
+            try:
+                return round(vertex.x(), mantissa) # Hook to Core
+            except:
+                return None
 
     @staticmethod
     def Y(vertex, mantissa: int = 6) -> float:
@@ -1752,11 +1754,13 @@ class Vertex():
             The Y coordinate of the input vertex.
 
         """
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(vertex, "Vertex"):
-            return None
-        return round(vertex.Y(), mantissa)
+        try:
+            return round(vertex.Y(), mantissa) # Hook to Core
+        except:
+            try:
+                return round(vertex.y(), mantissa) # Hook to Core
+            except:
+                return None
 
     @staticmethod
     def Z(vertex, mantissa: int = 6) -> float:
@@ -1776,9 +1780,11 @@ class Vertex():
             The Z coordinate of the input vertex.
 
         """
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(vertex, "Vertex"):
-            return None
-        return round(vertex.Z(), mantissa)
+        try:
+            return round(vertex.Z(), mantissa) # Hook to Core
+        except:
+            try:
+                return round(vertex.z(), mantissa) # Hook to Core
+            except:
+                return None
            

topologicpy/Wire.py

@@ -982,9 +982,9 @@ class Wire():
         sides = int(math.floor(sides))
         for i in range(sides+1):
             angle = fromAngle + math.radians(angleRange/sides)*i
-            x = math.sin(angle)*radius + origin.X()
-            y = math.cos(angle)*radius + origin.Y()
-            z = origin.Z()
+            x = math.sin(angle)*radius + Vertex.X(origin)
+            y = math.cos(angle)*radius + Vertex.Y(origin)
+            z = Vertex.Z(origin)
             xList.append(x)
             yList.append(y)
             baseV.append(Vertex.ByCoordinates(x, y, z))
@@ -1663,7 +1663,7 @@ class Wire():
 
         graph = []
         for anEdge in tEdges:
-            graph.append([vIndex(anEdge.StartVertex(), tVertices, tolerance), vIndex(anEdge.EndVertex(), tVertices, tolerance)]) # Hook to Core
+            graph.append([vIndex(Edge.StartVertex(anEdge), tVertices, tolerance), vIndex(Edge.EndVertex(anEdge), tVertices, tolerance)]) # Hook to Core
 
         cycles = []
         resultingCycles = main(graph, cycles, maxVertices)
@@ -1952,9 +1952,9 @@ class Wire():
         sides = int(math.floor(sides))
         for i in range(sides+1):
             angle = fromAngle + math.radians(angleRange/sides)*i
-            x = math.sin(angle)*a + origin.X()
-            y = math.cos(angle)*b + origin.Y()
-            z = origin.Z()
+            x = math.sin(angle)*a + Vertex.X(origin)
+            y = math.cos(angle)*b + Vertex.Y(origin)
+            z = Vertex.Z(origin)
             xList.append(x)
             yList.append(y)
             baseV.append(Vertex.ByCoordinates(x, y, z))
@@ -1968,8 +1968,8 @@ class Wire():
             baseWire = Topology.Translate(baseWire, a, b, 0)
         baseWire = Topology.Orient(baseWire, origin=origin, dirA=[0, 0, 1], dirB=direction)
         # Create a Cluster of the two foci
-        v1 = Vertex.ByCoordinates(c+origin.X(), 0+origin.Y(), 0)
-        v2 = Vertex.ByCoordinates(-c+origin.X(), 0+origin.Y(), 0)
+        v1 = Vertex.ByCoordinates(c+Vertex.X(origin), 0+Vertex.Y(origin), 0)
+        v2 = Vertex.ByCoordinates(-c+Vertex.X(origin), 0+Vertex.Y(origin), 0)
         foci = Cluster.ByTopologies([v1, v2])
         if placement.lower() == "lowerleft":
             foci = Topology.Translate(foci, a, b, 0)
@@ -2483,18 +2483,18 @@ class Wire():
             return False
 
         def angleBetweenEdges(e1, e2, tolerance=0.0001):
-            a = e1.EndVertex().X() - e1.StartVertex().X()
-            b = e1.EndVertex().Y() - e1.StartVertex().Y()
-            c = e1.EndVertex().Z() - e1.StartVertex().Z()
-            d = Vertex.Distance(e1.EndVertex(), e2.StartVertex())
+            a = Vertex.X(Edge.EndVertex(e1)) - Vertex.X(Edge.StartVertex(e1))
+            b = Vertex.Y(Edge.EndVertex(e1)) - Vertex.Y(Edge.StartVertex(e1))
+            c = Vertex.Z(Edge.EndVertex(e1)) - Vertex.Z(Edge.StartVertex(e1))
+            d = Vertex.Distance(Edge.EndVertex(e1), Edge.StartVertex(e2))
             if d <= tolerance:
-                d = e2.StartVertex().X() - e2.EndVertex().X()
-                e = e2.StartVertex().Y() - e2.EndVertex().Y()
-                f = e2.StartVertex().Z() - e2.EndVertex().Z()
+                d = Vertex.X(Edge.StartVertex(e2)) - Vertex.X(Edge.EndVertex(e2))
+                e = Vertex.Y(Edge.StartVertex(e2)) - Vertex.Y(Edge.EndVertex(e2))
+                f = Vertex.Z(Edge.StartVertex(e2)) - Vertex.Z(Edge.EndVertex(e2))
             else:
-                d = e2.EndVertex().X() - e2.StartVertex().X()
-                e = e2.EndVertex().Y() - e2.StartVertex().Y()
-                f = e2.EndVertex().Z() - e2.StartVertex().Z()
+                d = Vertex.X(Edge.EndVertex(e2)) - Vertex.X(Edge.StartVertex(e2))
+                e = Vertex.Y(Edge.EndVertex(e2)) - Vertex.Y(Edge.StartVertex(e2))
+                f = Vertex.Z(Edge.EndVertex(e2)) - Vertex.Z(Edge.StartVertex(e2))
             dotProduct = a*d + b*e + c*f
             modOfVector1 = math.sqrt( a*a + b*b + c*c)*math.sqrt(d*d + e*e + f*f) 
             angle = dotProduct/modOfVector1
@@ -2538,7 +2538,6 @@ class Wire():
             return True
         return False
 
-
     @staticmethod
     def IShape(origin=None,
             width=1,
@@ -3318,7 +3317,7 @@ class Wire():
             return None
         if not direction:
             direction = -1*Face.Normal(face, outputType="xyz", mantissa=mantissa)
-        large_face = Topology.Scale(face, face.CenterOfMass(), 500, 500, 500)
+        large_face = Topology.Scale(face, Topology.CenterOfMass(face), 500, 500, 500)
         edges = []
         _ = wire.Edges(None, edges)
         projected_edges = []
@@ -3328,8 +3327,8 @@ class Wire():
                 for edge in edges:
                     if edge:
                         if (Topology.Type(edge) == Topology.TypeID("Edge")):
-                            sv = edge.StartVertex()
-                            ev = edge.EndVertex()
+                            sv = Edge.StartVertex(edge)
+                            ev = Edge.EndVertex(edge)
 
                             psv = Vertex.Project(vertex=sv, face=large_face, direction=direction)
                             pev = Vertex.Project(vertex=ev, face=large_face, direction=direction)
@@ -3404,10 +3403,10 @@ class Wire():
             xOffset = -width*0.5
             yOffset = -length*0.5
 
-        vb1 = Vertex.ByCoordinates(origin.X()-width*0.5+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb2 = Vertex.ByCoordinates(origin.X()+width*0.5+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb3 = Vertex.ByCoordinates(origin.X()+width*0.5+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
-        vb4 = Vertex.ByCoordinates(origin.X()-width*0.5+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
+        vb1 = Vertex.ByCoordinates(Vertex.X(origin)-width*0.5+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb2 = Vertex.ByCoordinates(Vertex.X(origin)+width*0.5+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb3 = Vertex.ByCoordinates(Vertex.X(origin)+width*0.5+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
+        vb4 = Vertex.ByCoordinates(Vertex.X(origin)-width*0.5+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
 
         baseWire = Wire.ByVertices([vb1, vb2, vb3, vb4], True)
         if direction != [0, 0, 1]:
@@ -3628,6 +3627,88 @@ class Wire():
         else:
             return wire
     
+    @staticmethod
+    def Representation(wire, normalize: bool = True, rotate: bool = True, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Returns a normalized representation of a closed wire with alternating edge lengths and interior angles.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire.
+        normalize : bool , optional
+            If set to True, the lengths in the list are normalized so that the shortest edge has a length of 1. the default is True.
+        rotate : bool , optional
+            If set to True, the list is rotated such that the shortest edge appears first.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The representation list.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        import math
+
+        def angleBetweenEdges(e1, e2, tolerance=0.0001):
+            a = Vertex.X(Edge.EndVertex(e1)) - Vertex.X(Edge.StartVertex(e1))
+            b = Vertex.Y(Edge.EndVertex(e1)) - Vertex.Y(Edge.StartVertex(e1))
+            c = Vertex.Z(Edge.EndVertex(e1)) - Vertex.Z(Edge.StartVertex(e1))
+            d = Vertex.Distance(Edge.EndVertex(e1), Edge.StartVertex(e2))
+            if d <= tolerance:
+                d = Vertex.X(Edge.StartVertex(e2)) - Vertex.X(Edge.EndVertex(e2))
+                e = Vertex.Y(Edge.StartVertex(e2)) - Vertex.Y(Edge.EndVertex(e2))
+                f = Vertex.Z(Edge.StartVertex(e2)) - Vertex.Z(Edge.EndVertex(e2))
+            else:
+                d = Vertex.X(Edge.EndVertex(e2)) -  Vertex.X(Edge.StartVertex(e2))
+                e = Vertex.Y(Edge.EndVertex(e2)) - Vertex.Y(Edge.StartVertex(e2))
+                f = Vertex.Z(Edge.EndVertex(e2)) - Vertex.Z(Edge.StartVertex(e2))
+            dotProduct = a*d + b*e + c*f
+            modOfVector1 = math.sqrt( a*a + b*b + c*c)*math.sqrt(d*d + e*e + f*f) 
+            angle = dotProduct/modOfVector1
+            angleInDegrees = math.degrees(math.acos(angle))
+            return angleInDegrees
+
+        def getInteriorAngles(edges, tolerance=0.0001):
+            angles = []
+            for i in range(len(edges)-1):
+                e1 = edges[i]
+                e2 = edges[i+1]
+                angles.append(angleBetweenEdges(e1, e2, tolerance=tolerance))
+            return angles
+
+        def rotate_list_to_minimum(nums):
+            if not nums:
+                return nums  # Return the empty list as-is
+
+            min_index = nums.index(min(nums))
+            return nums[min_index:] + nums[:min_index]
+        
+        def getRep(edges, normalize=True, rotate=True, tolerance=0.0001):
+            angles = getInteriorAngles(edges, tolerance=tolerance)
+            lengths = []
+            normalizedLengths = []
+            for anEdge in edges:
+                lengths.append(Edge.Length(anEdge))
+            if normalize == True:
+                minLength = min(lengths)
+            else:
+                minLength = 1
+            for aLength in lengths:
+                normalizedLengths.append(aLength/minLength)
+            if rotate == True:
+                return rotate_list_to_minimum([x for x in itertools.chain(*itertools.zip_longest(normalizedLengths, angles)) if x is not None])
+            return [x for x in itertools.chain(*itertools.zip_longest(normalizedLengths, angles)) if x is not None]
+
+        edges = Topology.Edges(wire)
+        return_list = [round(x, mantissa) for x in getRep(edges, normalize=normalize, rotate=rotate, tolerance=tolerance)]
+        return return_list
+    
     @staticmethod
     def Reverse(wire, transferDictionaries = False, tolerance: float = 0.0001):
         """
@@ -3752,7 +3833,7 @@ class Wire():
             eb_vertices = Topology.Vertices(eb_wire)
             if normal[2] > 0:
                 eb_vertices = list(reversed(eb_vertices))
-            eb_polygon_coordinates = [(v.X(), v.Y(), v.Z()) for v in eb_vertices]
+            eb_polygon_coordinates = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in eb_vertices]
             eb_polygonxy = [(x[0], x[1]) for x in eb_polygon_coordinates]
 
             ib_polygonsxy = []
@@ -3761,7 +3842,7 @@ class Wire():
                 ib_vertices = Topology.Vertices(ib_wire)
                 if normal[2] > 0:
                     ib_vertices = list(reversed(ib_vertices))
-                ib_polygon_coordinates = [(v.X(), v.Y(), v.Z()) for v in ib_vertices]
+                ib_polygon_coordinates = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in ib_vertices]
                 ib_polygonxy = [(x[0], x[1]) for x in ib_polygon_coordinates]
                 ib_polygonsxy.append(ib_polygonxy)
                 zero_coordinates += ib_polygon_coordinates
@@ -3828,12 +3909,12 @@ class Wire():
 
         def perpendicular_distance(point, line_start, line_end):
             # Calculate the perpendicular distance from a point to a line segment
-            x0 = point.X()
-            y0 = point.Y()
-            x1 = line_start.X()
-            y1 = line_start.Y()
-            x2 = line_end.X()
-            y2 = line_end.Y()
+            x0 = Vertex.X(point)
+            y0 = Vertex.Y(point)
+            x1 = Vertex.X(line_start)
+            y1 = Vertex.Y(line_start)
+            x2 = Vertex.X(line_end)
+            y2 = Vertex.Y(line_end)
 
             numerator = abs((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1)
             denominator = Vertex.Distance(line_start, line_end)
@@ -3880,7 +3961,7 @@ class Wire():
             # Calculate the effective area for each point except the first and last
             def effective_area(p1, p2, p3):
                 # Triangle area formed by p1, p2, and p3
-                return 0.5 * abs(p1.X() * (p2.Y() - p3.Y()) + p2.X() * (p3.Y() - p1.Y()) + p3.X() * (p1.Y() - p2.Y()))
+                return 0.5 * abs(Vertex.X(p1) * (Vertex.Y(p2) - Vertex.Y(p3)) + Vertex.X(p2) * (Vertex.Y(p3) - Vertex.Y(p1)) + Vertex.X(p3) * (Vertex.Y(p1) - Vertex.Y(p2)))
 
             # Keep track of effective areas
             areas = [None]  # First point has no area
@@ -4358,9 +4439,9 @@ class Wire():
             else:
                 radius = radiusB
             angle = math.radians(360/sides)*i
-            x = math.sin(angle)*radius + origin.X()
-            y = math.cos(angle)*radius + origin.Y()
-            z = origin.Z()
+            x = math.sin(angle)*radius + Vertex.X(origin)
+            y = math.cos(angle)*radius + Vertex.Y(origin)
+            z = Vertex.Z(origin)
             xList.append(x)
             yList.append(y)
             baseV.append([x, y])
@@ -4368,29 +4449,29 @@ class Wire():
         if placement.lower() == "lowerleft":
             xmin = min(xList)
             ymin = min(yList)
-            xOffset = origin.X() - xmin
-            yOffset = origin.Y() - ymin
+            xOffset = Vertex.X(origin) - xmin
+            yOffset = Vertex.Y(origin) - ymin
         elif placement.lower() == "upperleft":
             xmin = min(xList)
             ymax = max(yList)
-            xOffset = origin.X() - xmin
-            yOffset = origin.Y() - ymax
+            xOffset = Vertex.X(origin) - xmin
+            yOffset = Vertex.Y(origin) - ymax
         elif placement.lower() == "lowerright":
             xmax = max(xList)
             ymin = min(yList)
-            xOffset = origin.X() - xmax
-            yOffset = origin.Y() - ymin
+            xOffset = Vertex.X(origin) - xmax
+            yOffset = Vertex.Y(origin) - ymin
         elif placement.lower() == "upperright":
             xmax = max(xList)
             ymax = max(yList)
-            xOffset = origin.X() - xmax
-            yOffset = origin.Y() - ymax
+            xOffset = Vertex.X(origin) - xmax
+            yOffset = Vertex.Y(origin) - ymax
         else:
             xOffset = 0
             yOffset = 0
         tranBase = []
         for coord in baseV:
-            tranBase.append(Vertex.ByCoordinates(coord[0]+xOffset, coord[1]+yOffset, origin.Z()))
+            tranBase.append(Vertex.ByCoordinates(coord[0]+xOffset, coord[1]+yOffset, Vertex.Z(origin)))
         
         baseWire = Wire.ByVertices(tranBase, True)
         baseWire = Wire.Reverse(baseWire)
@@ -4501,10 +4582,10 @@ class Wire():
             xOffset = -(max((widthA*0.5 + offsetA), (widthB*0.5 + offsetB)))
             yOffset = -length*0.5
 
-        vb1 = Vertex.ByCoordinates(origin.X()-widthA*0.5+offsetA+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb2 = Vertex.ByCoordinates(origin.X()+widthA*0.5+offsetA+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb3 = Vertex.ByCoordinates(origin.X()+widthB*0.5+offsetB+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
-        vb4 = Vertex.ByCoordinates(origin.X()-widthB*0.5++offsetB+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
+        vb1 = Vertex.ByCoordinates(Vertex.X(origin)-widthA*0.5+offsetA+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb2 = Vertex.ByCoordinates(Vertex.X(origin)+widthA*0.5+offsetA+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb3 = Vertex.ByCoordinates(Vertex.X(origin)+widthB*0.5+offsetB+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
+        vb4 = Vertex.ByCoordinates(Vertex.X(origin)-widthB*0.5++offsetB+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
 
         baseWire = Wire.ByVertices([vb1, vb2, vb3, vb4], True)
         if direction != [0, 0, 1]:

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.94'
+__version__ = '0.7.96'

{topologicpy-0.7.94.dist-info → topologicpy-0.7.96.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.94
+Version: 0.7.96
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.7.94.dist-info → topologicpy-0.7.96.dist-info}/RECORD

@@ -1,36 +1,36 @@
 topologicpy/ANN.py,sha256=m_WxD1lgQqDhUpaM20Lia6TmJACDYaAE96wigsi-99U,47932
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/BVH.py,sha256=mKVCAu9K8qzcWXtPDVH5usXZV1DNNNJl4n3rU5Lh1ZM,12931
-topologicpy/Cell.py,sha256=Fdqf2GCWfKe50EecBVcB8PCHKWENRUTTH8yPrOSF3-0,108321
-topologicpy/CellComplex.py,sha256=ncjfvJ2QJzz4Fu8BMaQBLxAQ6WHx6HfUCddaLP8kXsc,51480
+topologicpy/Cell.py,sha256=o5CxsBXxtnV439I4f8VMUoDMVwO5o3q0lHinHHMSmFg,108571
+topologicpy/CellComplex.py,sha256=-s8RKGa2H1eqLO7g6qyQvvuFMFJ0aIgXvIr9kOVgpjA,51608
 topologicpy/Cluster.py,sha256=__PvNVjRnFfy12aawd7HSrb3UBX3Rtd1iWSSQnPGpfk,55768
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
-topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
+topologicpy/DGL.py,sha256=M_znFtyPBJJz-iXLYZs2wwBj24fhevIo739dGha0chM,139041
 topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,33186
-topologicpy/Edge.py,sha256=KWOJCkLDwCWyZJ5MKwDhT5umWwCYBHtLOz6ulHrSOfY,67205
-topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
+topologicpy/Edge.py,sha256=gaLqyjFOqFHpw69Ftr4rc-kvakYpauQwhOK4ZO-V35g,67287
+topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=wczXpMcfub8Eb10lA4rrXksvi5YYCbRjBdp3lOTUwK0,172618
-topologicpy/Graph.py,sha256=oA647-h9McD0jm2JDsLl0DV93k5ikk8tSGxptlRgL-s,455440
+topologicpy/Graph.py,sha256=Zx4dzSTynaJP1dEZ1j5WuneaTv2N2fbeNTyMwaI947c,455395
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=F3h4_qcOD_PHAoVe0tEbEE7_jYyVcaHjtwVs4QHOZuI,23978
-topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
+topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
-topologicpy/Neo4j.py,sha256=t52hgE9cVsqkGc7m7fjRsLnyfRHakVHwdvF4ms7ow78,22342
+topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
 topologicpy/Plotly.py,sha256=Tvo0_zKVEHtPhsMNNvLy5G0HIys5FPAOyp_o4QN_I_A,115760
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
-topologicpy/Shell.py,sha256=UdDz3zfIYmGRjoZIseviJ2cXNtR5Kx5tIsZLhWMyO_U,87906
+topologicpy/Shell.py,sha256=fLRnQ79vtdBDRW1Xn8Gaap34XheGbw7UBFd-ALJ2Y1g,87978
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=d99wryPPXvw7eRw12GVKV-DT6jhlmVq6GsMAjg-E-40,441693
+topologicpy/Topology.py,sha256=kAnJrVyrwJX8c-C4q1cewJ80byG8uaoBWUuk0T6U4SY,441788
 topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
-topologicpy/Vertex.py,sha256=sYWTbAHqKGRUAJRCIUqrCO_xFhvsXK09Sx7E4dafPLQ,73754
-topologicpy/Wire.py,sha256=KDmnBzzM-9qNBt1vBPnj3t7g0y3R-sRFD2hz6zd769s,218625
+topologicpy/Vertex.py,sha256=QkeNPFTX-adKhEHMole0et9FCy0xXmTHVcmsYqqotSw,73904
+topologicpy/Wire.py,sha256=bX8wO96gFa7HZPY0CFlmYQBOUP_1e0jCb02BPxaY-ao,222981
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=t2Dbe3Vr_6iOI6IajmMK9OGe8SMnlHO_9Zd7vUrwzAg,23
-topologicpy-0.7.94.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.94.dist-info/METADATA,sha256=fh-3ZDxjF6yIejVjCdy7CR1S5prt8Ew8xS4KST5rZRw,10513
-topologicpy-0.7.94.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.94.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.94.dist-info/RECORD,,
+topologicpy/version.py,sha256=a9u4mrbOh52xm2kgTG2gE8Y-NjoOtc82edCsxZY1Zs0,23
+topologicpy-0.7.96.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.96.dist-info/METADATA,sha256=nVJinnZ504srDkDfjHbmyKZWpWEy6TchQp9nfijkKUY,10513
+topologicpy-0.7.96.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.96.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.96.dist-info/RECORD,,