topologicpy 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

topologicpy/Face.py

@@ -230,7 +230,7 @@ class Face(Topology):
                 for z in range(za,zb,zc):
                     if flag:
                         break
-                    t = Topology.Rotate(topology, origin=origin, x=0,y=0,z=1, degree=z)
+                    t = Topology.Rotate(topology, origin=origin, axis=[0, 0, 1], angle=z)
                     minX, minY, maxX, maxY = bb(t)
                     w = abs(maxX - minX)
                     l = abs(maxY - minY)
@@ -257,7 +257,7 @@ class Face(Topology):
 
         baseWire = Wire.ByVertices([vb1, vb2, vb3, vb4], close=True)
         baseFace = Face.ByWire(baseWire, tolerance=tolerance)
-        baseFace = Topology.Rotate(baseFace, origin=origin, x=0,y=0,z=1, degree=-best_z)
+        baseFace = Topology.Rotate(baseFace, origin=origin, axis=[0, 0, 1], angle=-best_z)
         dictionary = Dictionary.ByKeysValues(["zrot"], [best_z])
         baseFace = Topology.SetDictionary(baseFace, dictionary)
         return baseFace
@@ -484,7 +484,7 @@ class Face(Topology):
             return None
     
     @staticmethod
-    def ByVertices(vertices: list) -> topologic.Face:
+    def ByVertices(vertices: list, tolerance: float = 0.0001) -> topologic.Face:
         
         """
         Creates a face from the input list of vertices.
@@ -493,6 +493,8 @@ class Face(Topology):
         ----------
         vertices : list
             The input list of vertices.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -509,12 +511,12 @@ class Face(Topology):
         if len(vertexList) < 3:
             return None
         
-        w = Wire.ByVertices(vertexList)
-        f = Face.ByWire(w)
+        w = Wire.ByVertices(vertexList, tolerance=tolerance)
+        f = Face.ByWire(w, tolerance=tolerance)
         return f
 
     @staticmethod
-    def ByVerticesCluster(cluster: topologic.Cluster) -> topologic.Face:
+    def ByVerticesCluster(cluster: topologic.Cluster, tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a face from the input cluster of vertices.
 
@@ -522,6 +524,8 @@ class Face(Topology):
         ----------
         cluster : topologic.Cluster
             The input cluster of vertices.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -533,7 +537,7 @@ class Face(Topology):
         if not isinstance(cluster, topologic.Cluster):
             return None
         vertices = Cluster.Vertices(cluster)
-        return Face.ByVertices(vertices)
+        return Face.ByVertices(vertices, tolerance=tolerance)
 
     @staticmethod
     def ByWire(wire: topologic.Wire, tolerance: float = 0.0001, silent=False) -> topologic.Face:
@@ -705,7 +709,7 @@ class Face(Topology):
         return Face.ByWires(externalBoundary, internalBoundaries, tolerance=tolerance, silent=silent)
     
     @staticmethod
-    def NorthArrow(origin: topologic.Vertex = None, radius: float = 0.5, sides: int = 16, direction: list = [0,0,1], northAngle: float = 0.0,
+    def NorthArrow(origin: topologic.Vertex = None, radius: float = 0.5, sides: int = 16, direction: list = [0, 0, 1], northAngle: float = 0.0,
                    placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a north arrow.
@@ -713,13 +717,13 @@ class Face(Topology):
         Parameters
         ----------
         origin : topologic.Vertex, optional
-            The location of the origin of the circle. The default is None which results in the circle being placed at (0,0,0).
+            The location of the origin of the circle. The default is None which results in the circle being placed at (0, 0, 0).
         radius : float , optional
             The radius of the circle. The default is 1.
         sides : int , optional
             The number of sides of the circle. The default is 16.
         direction : list , optional
-            The vector representing the up direction of the circle. The default is [0,0,1].
+            The vector representing the up direction of the circle. The default is [0, 0, 1].
         northAngle : float , optional
             The angular offset in degrees from the positive Y axis direction. The angle is measured in a counter-clockwise fashion where 0 is positive Y, 90 is negative X, 180 is negative Y, and 270 is positive X.
         placement : str , optional
@@ -738,11 +742,11 @@ class Face(Topology):
         if not origin:
             origin = Vertex.Origin()
         
-        c = Face.Circle(origin=origin, radius=radius, sides=sides, direction=[0,0,1], placement="center", tolerance=tolerance)
+        c = Face.Circle(origin=origin, radius=radius, sides=sides, direction=[0, 0, 1], placement="center", tolerance=tolerance)
         r = Face.Rectangle(origin=origin, width=radius*0.01,length=radius*1.2, placement="lowerleft")
         r = Topology.Translate(r, -0.005*radius,0,0)
         arrow = Topology.Difference(c, r, tolerance=tolerance)
-        arrow = Topology.Rotate(arrow, Vertex.Origin(), 0,0,1,northAngle)
+        arrow = Topology.Rotate(arrow, origin=Vertex.Origin(), axis=[0, 0, 1], angle=northAngle)
         if placement.lower() == "lowerleft":
             arrow = Topology.Translate(arrow, radius, radius, 0)
         elif placement.lower() == "upperleft":
@@ -756,7 +760,7 @@ class Face(Topology):
         return arrow
 
     @staticmethod
-    def Circle(origin: topologic.Vertex = None, radius: float = 0.5, sides: int = 16, fromAngle: float = 0.0, toAngle: float = 360.0, direction: list = [0,0,1],
+    def Circle(origin: topologic.Vertex = None, radius: float = 0.5, sides: int = 16, fromAngle: float = 0.0, toAngle: float = 360.0, direction: list = [0, 0, 1],
                    placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a circle.
@@ -764,7 +768,7 @@ class Face(Topology):
         Parameters
         ----------
         origin : topologic.Vertex, optional
-            The location of the origin of the circle. The default is None which results in the circle being placed at (0,0,0).
+            The location of the origin of the circle. The default is None which results in the circle being placed at (0, 0, 0).
         radius : float , optional
             The radius of the circle. The default is 1.
         sides : int , optional
@@ -774,7 +778,7 @@ class Face(Topology):
         toAngle : float , optional
             The angle in degrees at which to end creating the arc of the circle. The default is 360.
         direction : list , optional
-            The vector representing the up direction of the circle. The default is [0,0,1].
+            The vector representing the up direction of the circle. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the circle. This can be "center", "lowerleft", "upperleft", "lowerright", or "upperright". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -880,19 +884,19 @@ class Face(Topology):
         return edges
 
     @staticmethod
-    def Einstein(origin: topologic.Vertex = None, radius: float = 0.5, direction: list = [0,0,1],
-                 placement: str = "center", tolerance: float=0.0001) -> topologic.Face:
+    def Einstein(origin: topologic.Vertex = None, radius: float = 0.5, direction: list = [0, 0, 1],
+                 placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates an aperiodic monotile, also called an 'einstein' tile (meaning one tile in German, not the name of the famous physist). See https://arxiv.org/abs/2303.10798
 
         Parameters
         ----------
         origin : topologic.Vertex , optional
-            The location of the origin of the tile. The default is None which results in the tiles first vertex being placed at (0,0,0).
+            The location of the origin of the tile. The default is None which results in the tiles first vertex being placed at (0, 0, 0).
         radius : float , optional
             The radius of the hexagon determining the size of the tile. The default is 0.5.
         direction : list , optional
-            The vector representing the up direction of the ellipse. The default is [0,0,1].
+            The vector representing the up direction of the ellipse. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the hexagon determining the location of the tile. This can be "center", or "lowerleft". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -927,7 +931,8 @@ class Face(Topology):
             internal boundaries (holes). For example: [[270,270,270,270], [[270,270,270,270],[300,300,300]]]. If not, the returned list will be
             a simple list of interior angles of the external boundary. For example: [270,270,270,270]. Please note that that the interior angles of the
             internal boundaries are considered to be those interior to the original face. Thus, they are exterior to the internal boundary.
-        
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         Returns
         -------
         list
@@ -1054,7 +1059,7 @@ class Face(Topology):
         return harmonizedFace
 
     @staticmethod
-    def InteriorAngles(face: topologic.Face, includeInternalBoundaries=False, mantissa: int = 6) -> list:
+    def InteriorAngles(face: topologic.Face, includeInternalBoundaries: bool = False, mantissa: int = 6) -> list:
         """
         Returns the interior angles of the input face in degrees. The face must be planar.
         
@@ -1068,7 +1073,8 @@ class Face(Topology):
             internal boundaries (holes). For example: [[90,90,90,90], [[90,90,90,90],[60,60,60]]]. If not, the returned list will be
             a simple list of interior angles of the external boundary. For example: [90,90,90,90]. Please note that that the interior angles of the
             internal boundaries are considered to be those interior to the original face. Thus, they are exterior to the internal boundary.
-        
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         Returns
         -------
         list
@@ -1269,7 +1275,7 @@ class Face(Topology):
         normal = Face.Normal(face)
         flatFace = Topology.Flatten(face, origin=origin, direction=normal)
 
-        # Create a Vertex at the world's origin (0,0,0)
+        # Create a Vertex at the world's origin (0, 0, 0)
         world_origin = Vertex.Origin()
 
         faceEdges = Face.Edges(flatFace)
@@ -1592,20 +1598,20 @@ class Face(Topology):
         return Face.Rectangle(origin=origin, width=width, length=length, direction = direction, placement=placement, tolerance=tolerance)
 
     @staticmethod
-    def Rectangle(origin: topologic.Vertex = None, width: float = 1.0, length: float = 1.0, direction: list = [0,0,1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
+    def Rectangle(origin: topologic.Vertex = None, width: float = 1.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a rectangle.
 
         Parameters
         ----------
         origin : topologic.Vertex, optional
-            The location of the origin of the rectangle. The default is None which results in the rectangle being placed at (0,0,0).
+            The location of the origin of the rectangle. The default is None which results in the rectangle being placed at (0, 0, 0).
         width : float , optional
             The width of the rectangle. The default is 1.0.
         length : float , optional
             The length of the rectangle. The default is 1.0.
         direction : list , optional
-            The vector representing the up direction of the rectangle. The default is [0,0,1].
+            The vector representing the up direction of the rectangle. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the rectangle. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -1680,18 +1686,18 @@ class Face(Topology):
         return Wire.Skeleton(face, tolerance=tolerance)
     
     @staticmethod
-    def Square(origin: topologic.Vertex = None, size: float = 1.0, direction: list = [0,0,1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
+    def Square(origin: topologic.Vertex = None, size: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a square.
 
         Parameters
         ----------
         origin : topologic.Vertex , optional
-            The location of the origin of the square. The default is None which results in the square being placed at (0,0,0).
+            The location of the origin of the square. The default is None which results in the square being placed at (0, 0, 0).
         size : float , optional
             The size of the square. The default is 1.0.
         direction : list , optional
-            The vector representing the up direction of the square. The default is [0,0,1].
+            The vector representing the up direction of the square. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the square. This can be "center", "lowerleft", "upperleft", "lowerright", or "upperright". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -1706,14 +1712,14 @@ class Face(Topology):
         return Face.Rectangle(origin=origin, width=size, length=size, direction=direction, placement=placement, tolerance=tolerance)
     
     @staticmethod
-    def Star(origin: topologic.Vertex = None, radiusA: float = 1.0, radiusB: float = 0.4, rays: int = 5, direction: list = [0,0,1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
+    def Star(origin: topologic.Vertex = None, radiusA: float = 1.0, radiusB: float = 0.4, rays: int = 5, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a star.
 
         Parameters
         ----------
         origin : topologic.Vertex, optional
-            The location of the origin of the star. The default is None which results in the star being placed at (0,0,0).
+            The location of the origin of the star. The default is None which results in the star being placed at (0, 0, 0).
         radiusA : float , optional
             The outer radius of the star. The default is 1.0.
         radiusB : float , optional
@@ -1721,7 +1727,7 @@ class Face(Topology):
         rays : int , optional
             The number of star rays. The default is 5.
         direction : list , optional
-            The vector representing the up direction of the star. The default is [0,0,1].
+            The vector representing the up direction of the star. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the star. This can be "center", "lowerleft", "upperleft", "lowerright", or "upperright". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -1741,14 +1747,14 @@ class Face(Topology):
         return Face.ByWire(wire, tolerance=tolerance)
 
     @staticmethod
-    def Trapezoid(origin: topologic.Vertex = None, widthA: float = 1.0, widthB: float = 0.75, offsetA: float = 0.0, offsetB: float = 0.0, length: float = 1.0, direction: list = [0,0,1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
+    def Trapezoid(origin: topologic.Vertex = None, widthA: float = 1.0, widthB: float = 0.75, offsetA: float = 0.0, offsetB: float = 0.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Face:
         """
         Creates a trapezoid.
 
         Parameters
         ----------
         origin : topologic.Vertex, optional
-            The location of the origin of the trapezoid. The default is None which results in the trapezoid being placed at (0,0,0).
+            The location of the origin of the trapezoid. The default is None which results in the trapezoid being placed at (0, 0, 0).
         widthA : float , optional
             The width of the bottom edge of the trapezoid. The default is 1.0.
         widthB : float , optional
@@ -1760,7 +1766,7 @@ class Face(Topology):
         length : float , optional
             The length of the trapezoid. The default is 1.0.
         direction : list , optional
-            The vector representing the up direction of the trapezoid. The default is [0,0,1].
+            The vector representing the up direction of the trapezoid. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the trapezoid. This can be "center", or "lowerleft". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -1780,7 +1786,7 @@ class Face(Topology):
         return Face.ByWire(wire, tolerance=tolerance)
 
     @staticmethod
-    def Triangulate(face:topologic.Face, tolerance: float = 0.0001) -> list:
+    def Triangulate(face:topologic.Face, mode: str = "classic", meshSize: float = None, tolerance: float = 0.0001) -> list:
         """
         Triangulates the input face and returns a list of faces.
 
@@ -1790,6 +1796,13 @@ class Face(Topology):
             The input face.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        mode : str , optional
+            The desired mode of meshing. Two options are available: "classic" and "mesh". They are case insensitive.
+            The "mesh" option uses the gmsh library.
+            WARNING: The "mesh" option can be very time consuming and can create very heavy geometry.
+        meshSize : float , optional
+            The desired size of the mesh when using the "mesh" option. If set to None, it will be
+            calculated automatically and set to 10% of the overall size of the face.
 
         Returns
         -------
@@ -1803,6 +1816,135 @@ class Face(Topology):
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
 
+        # This function was contributed by Yidan Xue.
+        def generate_gmsh(face, meshSize = None, tolerance = 0.0001):
+            """
+            Creates a gmsh of triangular meshes from the input face.
+
+            Parameters
+            ----------
+            face : topologic.Face
+                The input face.
+            meshSize : float , optional
+                The desired mesh size.
+            tolerance : float , optional
+                The desired tolerance. The default is 0.0001.
+            
+            Returns
+            ----------
+            topologic.Shell
+                The shell of triangular meshes.
+
+            """
+            import os
+            import warnings
+            try:
+                import numpy as np
+            except:
+                print("Face.Triangulate - Warning: Installing required numpy library.")
+                try:
+                    os.system("pip install numpy")
+                except:
+                    os.system("pip install numpy --user")
+                try:
+                    import numpy as np
+                    print("Face.Triangulate - Warning: numpy library installed correctly.")
+                except:
+                    warnings.warn("Face.Triangulate - Error: Could not import numpy. Please try to install numpy manually. Returning None.")
+                    return None
+            try:
+                import gmsh
+            except:
+                print("Face.Triangulate - Warning: Installing required gmsh library.")
+                try:
+                    os.system("pip install gmsh")
+                except:
+                    os.system("pip install gmsh --user")
+                try:
+                    import gmsh
+                    print("Face.Triangulate - Warning: gmsh library installed correctly.")
+                except:
+                    warnings.warn("Face.Triangulate - Error: Could not import gmsh. Please try to install gmsh manually. Returning None.")
+                    return None
+
+            import topologic
+            from topologicpy.Vertex import Vertex
+            from topologicpy.Wire import Wire
+            from topologicpy.Face import Face
+
+            if not isinstance(face, topologic.Face):
+                print("Shell.ByMeshFace - Error: The input face parameter is not a valid face. Returning None.")
+                return None
+            if not meshSize:
+                bounding_face = Face.BoundingRectangle(face)
+                bounding_face_vertices = Face.Vertices(bounding_face)
+                bounding_face_vertices_x = [Vertex.X(i) for i in bounding_face_vertices]
+                bounding_face_vertices_y = [Vertex.Y(i) for i in bounding_face_vertices]
+                width = max(bounding_face_vertices_x)-min(bounding_face_vertices_x)
+                length = max(bounding_face_vertices_y)-min(bounding_face_vertices_y)
+                meshSize = max([width,length])//10
+            
+            gmsh.initialize()
+            face_external_boundary = Face.ExternalBoundary(face)
+            external_vertices = Wire.Vertices(face_external_boundary)
+            external_vertex_number = len(external_vertices)
+            for i in range(external_vertex_number):
+                gmsh.model.geo.addPoint(Vertex.X(external_vertices[i]), Vertex.Y(external_vertices[i]), Vertex.Z(external_vertices[i]), meshSize, i+1)
+            for i in range(external_vertex_number):
+                if i < external_vertex_number-1:
+                    gmsh.model.geo.addLine(i+1, i+2, i+1)
+                else:
+                    gmsh.model.geo.addLine(i+1, 1, i+1)
+            gmsh.model.geo.addCurveLoop([i+1 for i in range(external_vertex_number)], 1)
+            current_vertex_number = external_vertex_number
+            current_edge_number = external_vertex_number
+            current_wire_number = 1
+
+            face_internal_boundaries = Face.InternalBoundaries(face)
+            if face_internal_boundaries:
+                internal_face_number = len(face_internal_boundaries)
+                for i in range(internal_face_number):
+                    face_internal_boundary = face_internal_boundaries[i]
+                    internal_vertices = Wire.Vertices(face_internal_boundary)
+                    internal_vertex_number = len(internal_vertices)
+                    for j in range(internal_vertex_number):
+                        gmsh.model.geo.addPoint(Vertex.X(internal_vertices[j]), Vertex.Y(internal_vertices[j]), Vertex.Z(internal_vertices[j]), meshSize, current_vertex_number+j+1)
+                    for j in range(internal_vertex_number):
+                        if j < internal_vertex_number-1:
+                            gmsh.model.geo.addLine(current_vertex_number+j+1, current_vertex_number+j+2, current_edge_number+j+1)
+                        else:
+                            gmsh.model.geo.addLine(current_vertex_number+j+1, current_vertex_number+1, current_edge_number+j+1)
+                    gmsh.model.geo.addCurveLoop([current_edge_number+i+1 for i in range(internal_vertex_number)], current_wire_number+1)
+                    current_vertex_number = current_vertex_number+internal_vertex_number
+                    current_edge_number = current_edge_number+internal_vertex_number
+                    current_wire_number = current_wire_number+1
+
+            gmsh.model.geo.addPlaneSurface([i+1 for i in range(current_wire_number)])
+            gmsh.model.geo.synchronize()
+            
+            gmsh.model.mesh.generate(2)         # For a 2D mesh
+            nodeTags, nodeCoords, nodeParams = gmsh.model.mesh.getNodes(-1, -1)
+            elemTypes, elemTags, elemNodeTags = gmsh.model.mesh.getElements(-1, -1)
+            gmsh.finalize()
+            
+            vertex_number = len(nodeTags)
+            vertices = []
+            for i in range(vertex_number):
+                vertices.append(Vertex.ByCoordinates(nodeCoords[3*i],nodeCoords[3*i+1],nodeCoords[3*i+2]))
+
+            faces = []
+            for n in range(len(elemTypes)):
+                vn = elemTypes[n]+1
+                et = elemTags[n]
+                ent = elemNodeTags[n]
+                if vn==3:
+                    for i in range(len(et)):
+                        face_vertices = []
+                        for j in range(vn):
+                            face_vertices.append(vertices[np.where(nodeTags==ent[i*vn+j])[0][0]])
+                        faces.append(Face.ByVertices(face_vertices))
+            return faces
+
         if not isinstance(face, topologic.Face):
             print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
             return None
@@ -1812,14 +1954,17 @@ class Face(Topology):
         origin = Topology.Centroid(face)
         normal = Face.Normal(face)
         flatFace = Topology.Flatten(face, origin=origin, direction=normal)
-    
-        shell_faces = []
-        for i in range(0,5,1):
-            try:
-                _ = topologic.FaceUtility.Triangulate(flatFace, float(i)*0.1, shell_faces)
-                break
-            except:
-                continue
+
+        if "mesh" in mode.lower():
+            shell_faces = generate_gmsh(flatFace, meshSize = meshSize, tolerance = tolerance)
+        else:
+            shell_faces = []
+            for i in range(0,5,1):
+                try:
+                    _ = topologic.FaceUtility.Triangulate(flatFace, float(i)*0.1, shell_faces)
+                    break
+                except:
+                    continue
         
         if len(shell_faces) < 1:
             return []