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

topologicpy/Face.py

@@ -131,8 +131,8 @@ class Face():
         if not Topology.IsInstance(faceB, "Face"):
             print("Face.Angle - Warning: The input faceB parameter is not a valid topologic face. Returning None.")
             return None
-        dirA = Face.NormalAtParameters(faceA, 0.5, 0.5, "xyz", 3)
-        dirB = Face.NormalAtParameters(faceB, 0.5, 0.5, "xyz", 3)
+        dirA = Face.Normal(faceA, outputType="xyz", mantissa=3)
+        dirB = Face.Normal(faceB, outputType="xyz", mantissa=3)
         return round((Vector.Angle(dirA, dirB)), mantissa)
 
     @staticmethod
@@ -258,11 +258,9 @@ class Face():
         return Face.ByEdges(edges, tolerance=tolerance)
 
     @staticmethod
-    def ByOffset(face, offset: float = 1.0, miter: bool = False,
-                 miterThreshold: float = None, offsetKey: str = None,
-                 miterThresholdKey: str = None, step: bool = True, tolerance: float = 0.0001):
+    def ByOffset(face, offset: float = 1.0, tolerance: float = 0.0001):
         """
-        Creates an offset face from the input face.
+        Creates an offset face from the input face. A positive offset value results in a smaller face to the inside of the input face.
 
         Parameters
         ----------
@@ -270,16 +268,6 @@ class Face():
             The input face.
         offset : float , optional
             The desired offset distance. The default is 1.0.
-        miter : bool , optional
-            if set to True, the corners will be mitered. The default is False.
-        miterThreshold : float , optional
-            The distance beyond which a miter should be added. The default is None which means the miter threshold is set to the offset distance multiplied by the square root of 2.
-        offsetKey : str , optional
-            If specified, the dictionary of the edges will be queried for this key to sepcify the desired offset. The default is None.
-        miterThresholdKey : str , optional
-            If specified, the dictionary of the vertices will be queried for this key to sepcify the desired miter threshold distance. The default is None.
-        step : bool , optional
-            If set to True, The transition between collinear edges with different offsets will be a step. Otherwise, it will be a continous edge. The default is True.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         
@@ -293,18 +281,18 @@ class Face():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.ByOffset - Warning: The input face parameter is not a valid toplogic face. Returning None.")
+            print("Face.ByOffset - Warning: The input face parameter is not a valid face. Returning None.")
             return None
         eb = Face.Wire(face)
         internal_boundaries = Face.InternalBoundaries(face)
-        offset_external_boundary = Wire.ByOffset(wire=eb, offset=offset, miter=miter, miterThreshold=miterThreshold, offsetKey=offsetKey, miterThresholdKey=miterThresholdKey, step=step)
+        offset_external_boundary = Wire.ByOffset(wire=eb, offset=offset, bisectors=False, tolerance=tolerance)
         offset_internal_boundaries = []
         for internal_boundary in internal_boundaries:
-            offset_internal_boundaries.append(Wire.ByOffset(wire=internal_boundary, offset=offset, miter=miter, miterThreshold=miterThreshold, offsetKey=offsetKey, miterThresholdKey=miterThresholdKey, step=step))
+            offset_internal_boundaries.append(Wire.ByOffset(wire=internal_boundary, offset=offset, bisectors=False, tolerance=tolerance))
         return Face.ByWires(offset_external_boundary, offset_internal_boundaries, tolerance=tolerance)
     
     @staticmethod
-    def ByShell(shell, origin= None, angTolerance: float = 0.1, tolerance: float = 0.0001):
+    def ByShell(shell, origin= None, angTolerance: float = 0.1, tolerance: float = 0.0001, silent=False):
         """
         Creates a face by merging the faces of the input shell.
 
@@ -351,13 +339,13 @@ class Face():
         face = None
         ext_boundary = Wire.RemoveCollinearEdges(Shell.ExternalBoundary(shell))
         if Topology.IsInstance(ext_boundary, "Wire"):
-            face = Face.ByWire(ext_boundary)
+            face = Face.ByWire(ext_boundary, silent=silent)
         elif Topology.IsInstance(ext_boundary, "Cluster"):
             wires = Topology.Wires(ext_boundary)
-            faces = [Face.ByWire(w) for w in wires]
+            faces = [Face.ByWire(w, silent=silent) for w in wires]
             areas = [Face.Area(f) for f in faces]
             wires = Helper.Sort(wires, areas, reverseFlags=[True])
-            face = Face.ByWires(wires[0], wires[1:])
+            face = Face.ByWires(wires[0], wires[1:], silent=silent)
 
         if Topology.IsInstance(face, "Face"):
             return face
@@ -420,6 +408,70 @@ class Face():
         else:
             return None
     
+    @staticmethod
+    def ByThickenedWire(wire, offsetA: float = 1.0, offsetB: float = 0.0, tolerance: float = 0.0001):
+        """
+        Creates a face by thickening the input wire. This method assumes the wire is manifold and planar.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire to be thickened.
+        offsetA : float , optional
+            The desired offset to the exterior of the wire. The default is 1.0.
+        offsetB : float , optional
+            The desired offset to the interior of the wire. The default is 0.0.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The created cell.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Vector import Vector
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(wire, "Wire"):
+            print("Face.ByThickenedWire - Error: The input wire parameter is not a valid wire. Returning None.")
+            return None
+        if not Wire.IsManifold(wire):
+            print("Face.ByThickenedWire - Error: The input wire parameter is not a manifold wire. Returning None.")
+            return None
+        three_vertices = Wire.Vertices(wire)[0:3]
+        temp_w = Wire.ByVertices(three_vertices, close=True)
+        flat_face = Face.ByWire(temp_w, tolerance=tolerance)
+        origin = Vertex.Origin()
+        normal = Face.Normal(flat_face)
+        flat_wire = Topology.Flatten(wire, origin=origin, direction=normal)
+        outside_wire = Wire.ByOffset(flat_wire, offset=abs(offsetA)*-1, bisectors = False, tolerance=tolerance)
+        inside_wire = Wire.ByOffset(flat_wire, offset=abs(offsetB), bisectors = False, tolerance=tolerance)
+        inside_wire = Wire.Reverse(inside_wire)
+        if not Wire.IsClosed(flat_wire):
+            sv = Topology.Vertices(flat_wire)[0]
+            ev = Topology.Vertices(flat_wire)[-1]
+            edges = Topology.Edges(flat_wire)
+            first_edge = Topology.SuperTopologies(sv, flat_wire, topologyType="edge")[0]
+            first_normal = Edge.Normal(first_edge)
+            last_edge = Topology.SuperTopologies(ev, flat_wire, topologyType="edge")[0]
+            last_normal = Edge.Normal(last_edge)
+            sv1 = Topology.TranslateByDirectionDistance(sv, first_normal, abs(offsetB))
+            sv2 = Topology.TranslateByDirectionDistance(sv, Vector.Reverse(first_normal), abs(offsetA))
+            ev1 = Topology.TranslateByDirectionDistance(ev, last_normal, abs(offsetB))
+            ev2 = Topology.TranslateByDirectionDistance(ev, Vector.Reverse(last_normal), abs(offsetA))
+            out_vertices = Topology.Vertices(outside_wire)[1:-1]
+            in_vertices = Topology.Vertices(inside_wire)[1:-1]
+            vertices = [sv2] + out_vertices + [ev2,ev1] + in_vertices + [sv1]
+            return_face = Face.ByWire(Wire.ByVertices(vertices))
+        else:
+            return_face = Face.ByWires(outside_wire, [inside_wire])
+        return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
+        return return_face
+    
     @staticmethod
     def ByVertices(vertices: list, tolerance: float = 0.0001):
         
@@ -808,7 +860,7 @@ class Face():
             return None
         if not north:
             north = Vector.North()
-        dirA = Face.NormalAtParameters(face,mantissa=mantissa)
+        dirA = Face.Normal(face, outputType="xyz", mantissa=mantissa)
         return Vector.CompassAngle(vectorA=dirA, vectorB=north, mantissa=mantissa, tolerance=tolerance)
 
     @staticmethod
@@ -839,7 +891,7 @@ class Face():
     def Einstein(origin= None, radius: float = 0.5, direction: list = [0, 0, 1],
                  placement: str = "center", tolerance: float = 0.0001):
         """
-        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
+        Creates an aperiodic monotile, also called an 'einstein' tile (meaning one tile in German, not the name of the famous physicist). See https://arxiv.org/abs/2303.10798
 
         Parameters
         ----------
@@ -869,6 +921,64 @@ class Face():
             return None
         return Face.ByWire(wire, tolerance=tolerance)
     
+    @staticmethod
+    def Ellipse(origin= None, inputMode: int = 1, width: float = 2.0, length: float = 1.0, focalLength: float = 0.866025, eccentricity: float = 0.866025, majorAxisLength: float = 1.0, minorAxisLength: float = 0.5, sides: float = 32, fromAngle: float = 0.0, toAngle: float = 360.0, close: bool = True, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates an ellipse and returns all its geometry and parameters.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the ellipse. The default is None which results in the ellipse being placed at (0, 0, 0).
+        inputMode : int , optional
+            The method by which the ellipse is defined. The default is 1.
+            Based on the inputMode value, only the following inputs will be considered. The options are:
+            1. Width and Length (considered inputs: width, length)
+            2. Focal Length and Eccentricity (considered inputs: focalLength, eccentricity)
+            3. Focal Length and Minor Axis Length (considered inputs: focalLength, minorAxisLength)
+            4. Major Axis Length and Minor Axis Length (considered input: majorAxisLength, minorAxisLength)
+        width : float , optional
+            The width of the ellipse. The default is 2.0. This is considered if the inputMode is 1.
+        length : float , optional
+            The length of the ellipse. The default is 1.0. This is considered if the inputMode is 1.
+        focalLength : float , optional
+            The focal length of the ellipse. The default is 0.866025. This is considered if the inputMode is 2 or 3.
+        eccentricity : float , optional
+            The eccentricity of the ellipse. The default is 0.866025. This is considered if the inputMode is 2.
+        majorAxisLength : float , optional
+            The length of the major axis of the ellipse. The default is 1.0. This is considered if the inputMode is 4.
+        minorAxisLength : float , optional
+            The length of the minor axis of the ellipse. The default is 0.5. This is considered if the inputMode is 3 or 4.
+        sides : int , optional
+            The number of sides of the ellipse. The default is 32.
+        fromAngle : float , optional
+            The angle in degrees from which to start creating the arc of the ellipse. The default is 0.
+        toAngle : float , optional
+            The angle in degrees at which to end creating the arc of the ellipse. The default is 360.
+        close : bool , optional
+            If set to True, arcs will be closed by connecting the last vertex to the first vertex. Otherwise, they will be left open.
+        direction : list , optional
+            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 ellipse. This can be "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Face
+            The created ellipse
+
+        """
+        from topologicpy.Wire import Wire
+        w = Wire.Ellipse(origin=origin, inputMode=inputMode, width=width, length=length,
+                         focalLength=focalLength, eccentricity=eccentricity,
+                         majorAxisLength=majorAxisLength, minorAxisLength=minorAxisLength,
+                         sides=sides, fromAngle=fromAngle, toAngle=toAngle,
+                         close=close, direction=direction,
+                         placement=placement, tolerance=tolerance)
+        return Face.ByWire(w)
+    
     @staticmethod
     def ExteriorAngles(face, includeInternalBoundaries=False, mantissa: int = 6) -> list:
         """
@@ -933,12 +1043,9 @@ class Face():
 
         eb = face.ExternalBoundary()
         f_dir = Face.Normal(face)
-        faceVertices = Topology.Vertices(eb)
-        temp_face = Face.ByWire(eb)
-        temp_dir = Face.Normal(temp_face)
-        if Vector.IsAntiParallel(f_dir, temp_dir):
-            faceVertices.reverse()
-        eb = Wire.ByVertices(faceVertices)
+        w_dir = Wire.Normal(eb)
+        if Vector.IsAntiParallel(f_dir, w_dir):
+            eb = Wire.Reverse(eb)
         return eb
     
     @staticmethod
@@ -1256,10 +1363,10 @@ class Face():
                 return None
 
         if not Topology.IsInstance(faceA, "Face"):
-            print("Face.IsInide - Error: The input faceA parameter is not a valid topologic face. Returning None.")
+            print("Face.IsInside - Error: The input faceA parameter is not a valid topologic face. Returning None.")
             return None
         if not Topology.IsInstance(faceB, "Face"):
-            print("Face.IsInide - Error: The input faceB parameter is not a valid topologic face. Returning None.")
+            print("Face.IsInside - Error: The input faceB parameter is not a valid topologic face. Returning None.")
             return None
 
         def normalize_plane_coefficients(plane):
@@ -1540,29 +1647,7 @@ class Face():
         return medialAxis
 
     @staticmethod
-    def Normal(face, outputType: str = "xyz", mantissa: int = 6) -> list:
-        """
-        Returns the normal vector to the input face. A normal vector of a face is a vector perpendicular to it.
-
-        Parameters
-        ----------
-        face : topologic_core.Face
-            The input face.
-        outputType : string , optional
-            The string defining the desired output. This can be any subset or permutation of "xyz". It is case insensitive. The default is "xyz".
-        mantissa : int , optional
-            The desired length of the mantissa. The default is 6.
-
-        Returns
-        -------
-        list
-            The normal vector to the input face. This is computed at the approximate center of the face.
-
-        """
-        return Face.NormalAtParameters(face, u=0.5, v=0.5, outputType=outputType, mantissa=mantissa)
-
-    @staticmethod
-    def NormalAtParameters(face, u: float = 0.5, v: float = 0.5, outputType: str = "xyz", mantissa: int = 6) -> list:
+    def Normal(face, outputType="xyz", mantissa=6):
         """
         Returns the normal vector to the input face. A normal vector of a face is a vector perpendicular to it.
 
@@ -1570,10 +1655,6 @@ class Face():
         ----------
         face : topologic_core.Face
             The input face.
-        u : float , optional
-            The *u* parameter at which to compute the normal to the input face. The default is 0.5.
-        v : float , optional
-            The *v* parameter at which to compute the normal to the input face. The default is 0.5.
         outputType : string , optional
             The string defining the desired output. This can be any subset or permutation of "xyz". It is case insensitive. The default is "xyz".
         mantissa : int , optional
@@ -1585,23 +1666,80 @@ class Face():
             The normal vector to the input face.
 
         """
-        returnResult = []
+        from topologicpy.Topology import Topology
+        from topologicpy.Vertex import Vertex
+        import os
+        import warnings
         try:
-            coords = topologic.FaceUtility.NormalAtParameters(face, u, v) # Hook to Core
-            x = round(coords[0], mantissa)
-            y = round(coords[1], mantissa)
-            z = round(coords[2], mantissa)
-            outputType = list(outputType.lower())
-            for axis in outputType:
-                if axis == "x":
-                    returnResult.append(x)
-                elif axis == "y":
-                    returnResult.append(y)
-                elif axis == "z":
-                    returnResult.append(z)
+            import numpy as np
         except:
-            returnResult = None
-        return returnResult
+            print("Face.Normal - 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.Normal - Warning: numpy library installed correctly.")
+            except:
+                warnings.warn("Face.Normal - Error: Could not import numpy. Please try to install numpy manually. Returning None.")
+                return None
+
+        if not Topology.IsInstance(face, "Face"):
+            print("Face.Normal - Error: The input face parameter is not a valid face. Returning None.")
+            return None
+        
+        vertices = Topology.Vertices(face)
+        vertices = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices]
+        
+        if len(vertices) < 3:
+            print("Face.Normal - Error: At least three vertices are required to define a plane. Returning None.")
+            return None
+        
+        # Convert vertices to numpy array for easier manipulation
+        vertices = np.array(vertices)
+        
+        # Try to find two non-collinear edge vectors
+        vec1 = None
+        vec2 = None
+        for i in range(1, len(vertices)):
+            for j in range(i + 1, len(vertices)):
+                temp_vec1 = vertices[i] - vertices[0]
+                temp_vec2 = vertices[j] - vertices[0]
+                cross_product = np.cross(temp_vec1, temp_vec2)
+                if np.linalg.norm(cross_product) > 1e-6:  # Check if the cross product is not near zero
+                    vec1 = temp_vec1
+                    vec2 = temp_vec2
+                    break
+            if vec1 is not None and vec2 is not None:
+                break
+        
+        if vec1 is None or vec2 is None:
+            print("Face.Normal - Error: The given vertices do not form a valid plane (all vertices might be collinear). Returning None.")
+            return None
+        
+        # Calculate the cross product of the two edge vectors
+        normal = np.cross(vec1, vec2)
+
+        # Normalize the normal vector
+        normal_length = np.linalg.norm(normal)
+        if normal_length == 0:
+            print("Face.Normal - Error: The given vertices do not form a valid plane (cross product resulted in a zero vector). Returning None.")
+            return None
+        
+        normal = normal / normal_length
+        normal = normal.tolist()
+        normal = [round(x, mantissa) for x in normal]
+        return_normal = []
+        outputType = list(outputType.lower())
+        for axis in outputType:
+            if axis == "x":
+                return_normal.append(normal[0])
+            elif axis == "y":
+                return_normal.append(normal[1])
+            elif axis == "z":
+                return_normal.append(normal[2])
+        return return_normal
     
     @staticmethod
     def NormalEdge(face, length: float = 1.0, tolerance: float = 0.0001, silent: bool = False):
@@ -1636,43 +1774,10 @@ class Face():
             return None
         iv = Face.InternalVertex(face)
         u, v = Face.VertexParameters(face, iv)
-        vec = Face.NormalAtParameters(face, u=u, v=v)
+        vec = Face.Normal(face)
         ev = Topology.TranslateByDirectionDistance(iv, vec, length)
         return Edge.ByVertices([iv, ev], tolerance=tolerance, silent=silent)
 
-    @staticmethod
-    def NormalEdgeAtParameters(face, u: float = 0.5, v: float = 0.5, length: float = 1.0, tolerance: float = 0.0001):
-        """
-        Returns the normal vector to the input face as an edge with the desired input length. A normal vector of a face is a vector perpendicular to it.
-
-        Parameters
-        ----------
-        face : topologic_core.Face
-            The input face.
-        u : float , optional
-            The *u* parameter at which to compute the normal to the input face. The default is 0.5.
-        v : float , optional
-            The *v* parameter at which to compute the normal to the input face. The default is 0.5.
-        length : float , optional
-            The desired length of the normal edge. The default is 1.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-        
-        Returns
-        -------
-        topologic_core.Edge
-            The created normal edge to the input face. This is computed at the approximate center of the face.
-
-        """
-        from topologicpy.Edge import Edge
-        from topologicpy.Topology import Topology
-        if not Topology.IsInstance(face, "Face"):
-            return None
-        sv = Face.VertexByParameters(face=face, u=u, v=v)
-        vec = Face.NormalAtParameters(face, u=u, v=v)
-        ev = Topology.TranslateByDirectionDistance(sv, vec, length)
-        return Edge.ByVertices([sv, ev], tolerance=tolerance, silent=True)
-
     @staticmethod
     def PlaneEquation(face, mantissa: int = 6) -> dict:
         """
@@ -1924,7 +2029,7 @@ class Face():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.Skeleton - Error: The input face is not a valid topologic face. Retruning None.")
+            print("Face.Skeleton - Error: The input face is not a valid topologic face. Returning None.")
             return None
         return Wire.Skeleton(face, tolerance=tolerance)