topologicpy 0.7.15__py3-none-any.whl → 0.7.18__py3-none-any.whl

topologicpy/Cell.py

@@ -377,6 +377,8 @@ class Cell():
             If set to True, the last wire in the list of input wires will be connected to the first wire in the list of input wires. The default is False.
         triangulate : bool , optional
             If set to True, the faces will be triangulated. The default is True.
+        planarize : bool, optional
+            If set to True, the created faces are planarized before building the cell. Otherwise, they are not. The default is False.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -858,8 +860,7 @@ class Cell():
         
         baseWire = Wire.Circle(origin=circle_origin, radius=radius, sides=uSides, fromAngle=0, toAngle=360, close=True, direction=[0, 0, 1], placement="center", tolerance=tolerance)
         baseFace = Face.ByWire(baseWire, tolerance=tolerance)
-        cylinder = Cell.ByThickenedFace(face=baseFace, thickness=height, bothSides=False, reverse=True,
-                            tolerance=tolerance)
+        cylinder = Cell.ByThickenedFace(face=baseFace, thickness=height, bothSides=False, tolerance=tolerance)
         if vSides > 1:
             cutting_planes = []
             baseX = Vertex.X(origin, mantissa=mantissa) + xOffset
@@ -909,7 +910,7 @@ class Cell():
         from topologicpy.Topology import Topology
 
         def angleCode(f, up, tiltAngle):
-            dirA = Face.NormalAtParameters(f)
+            dirA = Face.Normal(f)
             ang = round(Vector.Angle(dirA, up), 2)
             if abs(ang - 90) < tiltAngle:
                 code = 0
@@ -1032,14 +1033,14 @@ class Cell():
         cluster = Cluster.ByTopologies(pentagons)
         
         cluster2 = Topology.Rotate(cluster, origin=Vertex.Origin(), axis=[1, 0, 0], angle=180)
-        cluster2 = Topology.Rotate(cluster2, origin=Vertex.Origin(), axis=[0, 0, 1], angle=36)
-        vertices = Topology.Vertices(cluster2)
+        #cluster2 = Topology.Rotate(cluster2, origin=Vertex.Origin(), axis=[0, 0, 1], angle=36)
+        vertices = Topology.Vertices(cluster)
         zList = [Vertex.Z(v) for v in vertices]
         zList = list(set(zList))
         zList.sort()
-        zoffset1 = zList[-1] - zList[0]
-        zoffset2 = zList[1] - zList[0]
-        cluster2 = Topology.Translate(cluster2, 0, 0, -zoffset1-zoffset2)
+        zoffset = zList[1] - zList[0]
+        total_height = zList[-1] - zList[0]
+        cluster2 = Topology.Translate(cluster2, 0, 0, total_height+zoffset)
         pentagons += Topology.Faces(cluster2)
         dodecahedron = Cell.ByFaces(pentagons, tolerance=tolerance)
         centroid = Topology.Centroid(dodecahedron)
@@ -1052,6 +1053,12 @@ class Cell():
         elif placement == "lowerleft":
             dodecahedron = Topology.Translate(dodecahedron, radius, radius, radius)
         
+        geo = Topology.Geometry(dodecahedron)
+        vertices = [Vertex.ByCoordinates(coords) for coords in geo['vertices']]
+        vertices = Vertex.Fuse(vertices)
+        coords = [Vertex.Coordinates(v) for v in vertices]
+        dodecahedron = Topology.RemoveCoplanarFaces(Topology.SelfMerge(Topology.ByGeometry(vertices=coords, faces=geo['faces'])))
+        print(dodecahedron)
         dodecahedron = Topology.Orient(dodecahedron, origin=Vertex.Origin(), dirA=[0, 0, 1], dirB=direction, tolerance=tolerance)
         dodecahedron = Topology.Place(dodecahedron, originA=Vertex.Origin(), originB=origin)
         return dodecahedron
@@ -1393,7 +1400,7 @@ class Cell():
 
         icosahedron = Cell.ByFaces([f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,
                         f11,f12,f13,f14,f15,f16,f17,f18,f19,f20], tolerance=tolerance)
-        sf = 1.051*0.5 # To insribe it in a sphere of radius 0.5
+        sf = 1.051*0.5 # To inscribe it in a sphere of radius 0.5
         icosahedron = Topology.Scale(icosahedron, origin=Vertex.Origin(), x=sf, y=sf, z=sf)
         sf = radius/0.5
         icosahedron = Topology.Scale(icosahedron, origin=Vertex.Origin(), x=sf, y=sf, z=sf)
@@ -1823,7 +1830,7 @@ class Cell():
         ----------
         face : topologic_core.Face
             The input face.
-        angle : float , optioal
+        angle : float , optional
             The desired angle in degrees of the roof. The default is 45.
         epsilon : float , optional
             The desired epsilon (another form of tolerance for distance from plane). The default is 0.01. (This is set to a larger number as it was found to work better)
@@ -1865,7 +1872,7 @@ class Cell():
         Returns
         -------
         list
-            The classified list of input cells based on their encolsure within the input list of super cells.
+            The classified list of input cells based on their enclosure within the input list of super cells.
 
         """
 
@@ -1972,7 +1979,7 @@ class Cell():
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Sphere - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        c = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=vSides, fromAngle=-90, toAngle=90, close=False, direction=[0, 0, 1], placement="center")
+        c = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=vSides, fromAngle=0, toAngle=180, close=False, direction=[0, 0, 1], placement="center")
         c = Topology.Rotate(c, origin=Vertex.Origin(), axis=[1, 0, 0], angle=90)
         sphere = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0, 0, 1], angle=360, sides=uSides, tolerance=tolerance)
         if Topology.Type(sphere) == Topology.TypeID("CellComplex"):

topologicpy/CellComplex.py

@@ -467,7 +467,7 @@ class CellComplex():
         from topologicpy.Topology import Topology
 
         def angleCode(f, up, tiltAngle):
-            dirA = Face.NormalAtParameters(f)
+            dirA = Face.Normal(f)
             ang = round(Vector.Angle(dirA, up), 2)
             if abs(ang - 90) < tiltAngle:
                 code = 0
@@ -1132,9 +1132,9 @@ class CellComplex():
                 vertices = Topology.Vertices(cell)
         else:
             vertices += Topology.Vertices(cell)
-        vertices = [v for v in vertices if (Vertex.IsInternal(v, cell) or not Vertex.Index(v, Topology.Vertices(cell)) == None)]
+        vertices = [v for v in vertices if (Vertex.IsInternal(v, cell) or not Vertex.Index(v, Topology.Vertices(cell), tolerance=tolerance) == None)]
         if len(vertices) < 1:
-            print("CellComplex.Voronoi - Error: The input vertices parame ter does not contain any vertices that are inside the input cell parameter. Returning None.")
+            print("CellComplex.Voronoi - Error: The input vertices parameter does not contain any vertices that are inside the input cell parameter. Returning None.")
             return None
         voronoi_points = np.array([Vertex.Coordinates(v) for v in vertices])
         cluster = fracture_with_voronoi(voronoi_points)

topologicpy/DGL.py

@@ -92,7 +92,7 @@ except:
         from dgl import save_graphs, load_graphs
         print("DGL - dgl library installed correctly.")
     except:
-        warnings.warn("DGL - Error: Could not import dgl. The installation of the correct version of the dgl library is not trivial and is highly dependent on your hardward and software configuration. Please consult the dgl installation instructions.")
+        warnings.warn("DGL - Error: Could not import dgl. The installation of the correct version of the dgl library is not trivial and is highly dependent on your hardware and software configuration. Please consult the dgl installation instructions.")
 
 try:
     from tqdm.auto import tqdm

topologicpy/Edge.py

@@ -84,13 +84,39 @@ class Edge():
             The created bisecting edge.
 
         """
-        import numpy as np
-
+        from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
+        import numpy as np
 
+
+        def process_edges(edge1, edge2, tolerance=0.0001):
+            start1 = Edge.StartVertex(edge1)
+            end1 = Edge.EndVertex(edge1)
+            start2 = Edge.StartVertex(edge2)
+            end2 = Edge.EndVertex(edge2)
+            
+            shared_vertex = None
+            
+            if Vertex.Distance(start1, start2) < tolerance:
+                shared_vertex = start1
+            elif Vertex.Distance(start1, end2) < tolerance:
+                shared_vertex = start1
+                edge2 = Edge.Reverse(edge2)
+            elif Vertex.Distance(end1, start2) < tolerance:
+                shared_vertex = start2
+                edge1 = Edge.Reverse(edge1)
+            elif Vertex.Distance(end1, end2) < tolerance:
+                shared_vertex = end1
+                edge1 = Edge.Reverse(edge1)
+                edge2 = Edge.Reverse(edge2)
+            
+            if shared_vertex is None:
+                return [None, None]
+            return edge1, edge2
+        
         if not Topology.IsInstance(edgeA, "Edge"):
             print("Edge.Bisect - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
             return None
@@ -104,21 +130,21 @@ class Edge():
             print("Edge.Bisect - Error: The input edgeB parameter is shorter than the input tolerance parameter. Returning None.")
             return None
         
-        wire = Topology.SelfMerge(Cluster.ByTopologies([edgeA, edgeB]), tolerance=tolerance)
-        if not Topology.IsInstance(wire, "Wire"):
+        
+        edge1, edge2 = process_edges(edgeA, edgeB, tolerance=tolerance)
+        if edge1 == None or edge2 == None:
             print("Edge.Bisect - Error: The input edgeA and edgeB parameters do not share a vertex and thus cannot be bisected. Returning None.")
             return None
-        edges = Topology.Edges(wire)
-        edgeA = edges[0]
-        edgeB = edges[1]
-
-        sv = Wire.Vertices(wire)[1]
-
-        dirA = Edge.Direction(edgeA)
-        dirB = Edge.Direction(edgeB)
-        bisecting_vector = Vector.Bisect(dirA, dirB)
+        sv = Edge.StartVertex(edge1)
+        dir1 = Edge.Direction(edge1)
+        dir2 = Edge.Direction(edge2)
+        bisecting_vector = Vector.Bisect(dir1, dir2)
         ev = Topology.TranslateByDirectionDistance(sv, bisecting_vector, length)
         bisecting_edge = Edge.ByVertices([sv, ev])
+        if placement == 0:
+            bisecting_edge = Topology.TranslateByDirectionDistance(bisecting_edge, Vector.Reverse(bisecting_vector), length*0.5)
+        elif placement == 2:
+            bisecting_edge = Topology.TranslateByDirectionDistance(bisecting_edge, Vector.Reverse(bisecting_vector), length)
         return bisecting_edge
 
     @staticmethod
@@ -130,7 +156,7 @@ class Edge():
         ----------
         face : topologic_core.Face
             The input face
-        origin : toopologic.Vertex , optional
+        origin : topologic_core.Vertex , optional
             The desired origin of the edge. If set to None, the centroid of the face is chosen as the origin of the edge. The default is None.
         length : float , optional
             The desired length of the edge. The default is 1.
@@ -178,7 +204,7 @@ class Edge():
             The input edge.
         offset : float , optional
             The desired offset. The default is 1.
-        tolerance : float , optiona
+        tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
         Returns
@@ -206,7 +232,7 @@ class Edge():
         ----------
         vertexA : topologic_core.Vertex
             The first input vertex. This is considered the start vertex.
-        vertexB : toopologic.Vertex
+        vertexB : topologic_core.Vertex
             The second input vertex. This is considered the end vertex.
         tolerance : float , optional
             The desired tolerance to decide if an Edge can be created. The default is 0.0001.
@@ -481,7 +507,7 @@ class Edge():
             if not silent:
                 print("Edge.ExtendToEdge - Error: The input edges are not coplanar. Returning the original edge.")
             return edgeA
-        if not Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+        if Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
             if not silent:
                 print("Edge.ExtendToEdge - Error: The input edges are parallel. Returning the original edge.")
             return edgeA
@@ -789,8 +815,8 @@ class Edge():
 
         x1, y1, z1 = Vertex.Coordinates(Edge.StartVertex(edgeA), mantissa=mantissa)
         x2, y2, z2 = Vertex.Coordinates(Edge.EndVertex(edgeA), mantissa=mantissa)
-        x3, y3, z3 = Vertex.Coordinates(Edge.StartVertex(edgeA), mantissa=mantissa)
-        x4, y4, z4 = Vertex.Coordinates(Edge.EndVertex(edgeA), mantissa=mantissa)
+        x3, y3, z3 = Vertex.Coordinates(Edge.StartVertex(edgeB), mantissa=mantissa)
+        x4, y4, z4 = Vertex.Coordinates(Edge.EndVertex(edgeB), mantissa=mantissa)
         line1 = ((x1, y1, z1), (x2, y2, z2))
         line2 = ((x3, y3, z3), (x4, y4, z4))
         return are_lines_parallel(line1, line2, tolerance=tolerance)
@@ -1239,7 +1265,7 @@ class Edge():
             if not silent:
                 print("Edge.TrimByEdge - Error: The input edges are not coplanar. Returning the original edge.")
             return edgeA
-        if not Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+        if Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
             if not silent:
                 print("Edge.TrimByEdge - Error: The input edges are parallel. Returning the original edge.")
             return edgeA