topologicpy 0.8.30__py3-none-any.whl → 0.8.33__py3-none-any.whl

topologicpy/Face.py

@@ -571,6 +571,9 @@ class Face():
             The desired angular tolerance. The default is 0.1.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
 
         Returns
         -------
@@ -604,8 +607,7 @@ class Face():
         
         # Try the simple method first
         face = None
-        ext_boundary = Wire.RemoveCollinearEdges(Shell.ExternalBoundary(shell))
-        #ext_boundary = Shell.ExternalBoundary(shell)
+        ext_boundary = Wire.RemoveCollinearEdges(Shell.ExternalBoundary(shell), tolerance=tolerance, silent=silent)
         if Topology.IsInstance(ext_boundary, "Wire"):
             face = Face.ByWire(ext_boundary, silent=silent)
         elif Topology.IsInstance(ext_boundary, "Cluster"):
@@ -629,7 +631,7 @@ class Face():
             new_vertices.append(new_v)
         planar_shell = Topology.SelfMerge(Topology.ReplaceVertices(planar_shell, verticesA=vertices, verticesB=new_vertices), tolerance=tolerance)
         ext_boundary = Shell.ExternalBoundary(planar_shell, tolerance=tolerance)
-        ext_boundary = Topology.RemoveCollinearEdges(ext_boundary, angTolerance)
+        ext_boundary = Topology.RemoveCollinearEdges(ext_boundary, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
         if not Topology.IsInstance(ext_boundary, "Topology"):
             print("Face.ByShell - Error: Could not derive the external boundary of the input shell parameter. Returning None.")
             return None
@@ -637,9 +639,9 @@ class Face():
         if Topology.IsInstance(ext_boundary, "Wire"):
             if not Topology.IsPlanar(ext_boundary, tolerance=tolerance):
                 ext_boundary = Wire.Planarize(ext_boundary, origin=origin, tolerance=tolerance)
-            ext_boundary = Topology.RemoveCollinearEdges(ext_boundary, angTolerance)
+            ext_boundary = Topology.RemoveCollinearEdges(ext_boundary, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             try:
-                face = Face.ByWire(ext_boundary)
+                face = Face.ByWire(ext_boundary, tolerance=tolerance, silent=silent)
                 face = Topology.Unflatten(face, origin=origin, direction=normal)
                 return face
             except:
@@ -663,11 +665,11 @@ class Face():
             int_wires = []
             for int_boundary in int_boundaries:
                 temp_wires = Topology.Wires(int_boundary)
-                int_wires.append(Topology.RemoveCollinearEdges(temp_wires[0], angTolerance))
+                int_wires.append(Topology.RemoveCollinearEdges(temp_wires[0], angTolerance=angTolerance, tolerance=tolerance, silent=silent))
                 #int_wires.append(temp_wires[0])
 
             temp_wires = Topology.Wires(ext_boundary)
-            ext_wire = Topology.RemoveCollinearEdges(temp_wires[0], angTolerance)
+            ext_wire = Topology.RemoveCollinearEdges(temp_wires[0], angTolerance=angTolerance, tolerance=tolerance, silent=silent)
             #ext_wire = temp_wires[0]
             face = Face.ByWires(ext_wire, int_wires)
             face = Topology.Unflatten(face, origin=origin, direction=normal)
@@ -676,7 +678,7 @@ class Face():
             return None
     
     @staticmethod
-    def ByThickenedWire(wire, offsetA: float = 1.0, offsetB: float = 0.0, tolerance: float = 0.0001):
+    def ByThickenedWire(wire, offsetA: float = 1.0, offsetB: float = 0.0, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a face by thickening the input wire. This method assumes the wire is manifold and planar.
 
@@ -690,6 +692,8 @@ class Face():
             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.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -710,7 +714,7 @@ class Face():
             print("Face.ByThickenedWire - Error: The input wire parameter is not a manifold wire. Returning None.")
             return None
         three_vertices = Topology.Vertices(wire)[0:3]
-        temp_w = Wire.ByVertices(three_vertices, close=True)
+        temp_w = Wire.ByVertices(three_vertices, close=True, tolerance=tolerance, silent=silent)
         flat_face = Face.ByWire(temp_w, tolerance=tolerance)
         origin = Vertex.Origin()
         normal = Face.Normal(flat_face)
@@ -733,7 +737,7 @@ class Face():
             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))
+            return_face = Face.ByWire(Wire.ByVertices(vertices, close=True, tolerance=tolerance, silent=silent))
         else:
             return_face = Face.ByWires(outside_wire, [inside_wire])
         return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
@@ -773,7 +777,7 @@ class Face():
                 print("Face.ByVertices - Error: The input vertices parameter does not contain at least three valid vertices. Returning None.")
             return None
         
-        w = Wire.ByVertices(vertexList, tolerance=tolerance)
+        w = Wire.ByVertices(vertexList, close=True, tolerance=tolerance, silent=silent)
         if not Topology.IsInstance(w, "Wire"):
             if not silent:
                 print("Face.ByVertices - Error: Could not create the base wire. Returning None.")
@@ -782,8 +786,8 @@ class Face():
             if not silent:
                 print("Face.ByVertices - Error: Could not create a closed base wire. Returning None.")
             return None
-        f = Face.ByWire(w, tolerance=tolerance)
-        if not Topology.IsInstance(w, "Wire"):
+        f = Face.ByWire(w, tolerance=tolerance, silent=silent)
+        if not Topology.IsInstance(f, "Face"):
             if not silent:
                 print("Face.ByVertices - Error: Could not create the face. Returning None.")
             return None
@@ -851,7 +855,7 @@ class Face():
         import inspect
 
         def triangulateWire(wire):
-            wire = Topology.RemoveCollinearEdges(wire)
+            wire = Topology.RemoveCollinearEdges(wire, angTolerance=0.1, tolerance=tolerance, silent=silent)
             vertices = Topology.Vertices(wire)
             shell = Shell.Delaunay(vertices)
             if Topology.IsInstance(shell, "Topology"):
@@ -1000,58 +1004,75 @@ class Face():
         else:
             internalBoundaries = Cluster.Wires(internalBoundariesCluster)
         return Face.ByWires(externalBoundary, internalBoundaries, tolerance=tolerance, silent=silent)
-    
+
     @staticmethod
-    def NorthArrow(origin= None, radius: float = 0.5, sides: int = 16, direction: list = [0, 0, 1], northAngle: float = 0.0,
-                   placement: str = "center", tolerance: float = 0.0001):
+    def CHS(origin= None, radius: float = 0.5, thickness: float = 0.25, sides: int = 16, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001, silent: bool = False):
         """
-        Creates a north arrow.
+        Creates a circular hollow section (CHS).
 
         Parameters
         ----------
         origin : topologic_core.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 CHS. The default is None which results in the CHS 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.
+            The outer radius of the CHS. The default is 0.5.
+        thickness : float , optional
+            The thickness of the CHS. The default is 0.25.
         direction : list , optional
-            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.
+            The vector representing the up direction of the CHS. 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".
+            The description of the placement of the origin of the CHS. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
         topologic_core.Face
-            The created circle.
+            The created face.
 
         """
-        from topologicpy.Topology import Topology
         from topologicpy.Vertex import Vertex
-        if not Topology.IsInstance(origin, "Vertex"):
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+        
+        if thickness >= radius:
+            if not silent:
+                print("Face.SHS - Error: The thickness value is larger than or equal to the outer radius value. Returning None.")
+            return None
+        if origin == None:
             origin = Vertex.Origin()
         
-        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, origin=Vertex.Origin(), axis=[0, 0, 1], angle=northAngle)
+        outer_wire = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=sides, direction=[0,0,1], placement="center", tolerance=tolerance)
+        inner_wire = Wire.Circle(origin=Vertex.Origin(), radius=radius-thickness, sides=sides, direction=[0,0,1], placement="center", tolerance=tolerance)
+        return_face = Face.ByWires(outer_wire, [inner_wire])
+        if not Topology.IsInstance(return_face, "face"):
+            if not silent:
+                print("Face.CHS - Error: Could not create the face for the CHS. Returning None.")
+            return None
+        
+        xOffset = 0
+        yOffset = 0
+        zOffset = 0
         if placement.lower() == "lowerleft":
-            arrow = Topology.Translate(arrow, radius, radius, 0)
+            xOffset = radius
+            yOffset = radius
         elif placement.lower() == "upperleft":
-            arrow = Topology.Translate(arrow, radius, -radius, 0)
+            xOffset = radius
+            yOffset = -radius
         elif placement.lower() == "lowerright":
-            arrow = Topology.Translate(arrow, -radius, radius, 0)
+            xOffset = -radius
+            yOffset = radius
         elif placement.lower() == "upperright":
-            arrow = Topology.Translate(arrow, -radius, -radius, 0)
-        arrow = Topology.Place(arrow, originA=Vertex.Origin(), originB=origin)
-        arrow = Topology.Orient(arrow, origin=origin, dirA=[0,0,1], dirB=direction)
-        return arrow
-
+            xOffset = -radius
+            yOffset = -radius
+        return_face = Topology.Translate(return_face, x=xOffset, y=yOffset, z=zOffset)
+        return_face = Topology.Place(return_face, originA=Vertex.Origin(), originB=origin)
+        if direction != [0, 0, 1]:
+            return_face = Topology.Orient(return_face, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return return_face
+    
     @staticmethod
     def Circle(origin= 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):
@@ -1214,19 +1235,19 @@ class Face():
 
         if not isinstance(width, int) and not isinstance(width, float):
             if not silent:
-                print("Wire.CrossShape - Error: The width input parameter is not a valid number. Returning None.")
+                print("Face.CrossShape - Error: The width input parameter is not a valid number. Returning None.")
             return None
         if not isinstance(length, int) and not isinstance(length, float):
             if not silent:
-                print("Wire.CrossShape - Error: The length input parameter is not a valid number. Returning None.")
+                print("Face.CrossShape - Error: The length input parameter is not a valid number. Returning None.")
             return None
         if not isinstance(a, int) and not isinstance(a, float):
             if not silent:
-                print("Wire.CrossShape - Error: The a input parameter is not a valid number. Returning None.")
+                print("Face.CrossShape - Error: The a input parameter is not a valid number. Returning None.")
             return None
         if not isinstance(b, int) and not isinstance(b, float):
             if not silent:
-                print("Wire.CrossShape - Error: The b input parameter is not a valid number. Returning None.")
+                print("Face.CrossShape - Error: The b input parameter is not a valid number. Returning None.")
             return None
         if c == None:
             c = width/2
@@ -1234,72 +1255,72 @@ class Face():
             d = length/2
         if not isinstance(c, int) and not isinstance(c, float):
             if not silent:
-                print("Wire.CrossShape - Error: The c input parameter is not a valid number. Returning None.")
+                print("Face.CrossShape - Error: The c input parameter is not a valid number. Returning None.")
             return None
         if not isinstance(d, int) and not isinstance(d, float):
             if not silent:
-                print("Wire.CrossShape - Error: The d input parameter is not a valid number. Returning None.")
+                print("Face.CrossShape - Error: The d input parameter is not a valid number. Returning None.")
         if width <= tolerance:
             if not silent:
-                print("Wire.CrossShape - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+                print("Face.CrossShape - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
             return None
         if length <= tolerance:
             if not silent:
-                print("Wire.CrossShape - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+                print("Face.CrossShape - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
             return None
         if a <= tolerance:
             if not silent:
-                print("Wire.CrossShape - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+                print("Face.CrossShape - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
             return None
         if b <= tolerance:
             if not silent:
-                print("Wire.CrossShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+                print("Face.CrossShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
             return None
         if c <= tolerance:
             if not silent:
-                print("Wire.CrossShape - Error: The c input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+                print("Face.CrossShape - Error: The c input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
             return None
         if d <= tolerance:
             if not silent:
-                print("Wire.CrossShape - Error: The d input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+                print("Face.CrossShape - Error: The d input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
             return None
         if a >= (width - tolerance*2):
             if not silent:
-                print("Wire.CrossShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+                print("Face.CrossShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
             return None
         if b >= (length - tolerance*2):
             if not silent:
-                print("Wire.CrossShape - Error: The b input parameter must be less than the length input parameter. Returning None.")
+                print("Face.CrossShape - Error: The b input parameter must be less than the length input parameter. Returning None.")
             return None
         if c <= (tolerance + a/2):
             if not silent:
-                print("Wire.CrossShape - Error: The c input parameter must be more than half the a input parameter. Returning None.")
+                print("Face.CrossShape - Error: The c input parameter must be more than half the a input parameter. Returning None.")
             return None
         if d <= (tolerance + b/2):
             if not silent:
-                print("Wire.CrossShape - Error: The c input parameter must be more than half the b input parameter. Returning None.")
+                print("Face.CrossShape - Error: The c input parameter must be more than half the b input parameter. Returning None.")
             return None
         if c >= (width - tolerance - a/2):
             if not silent:
-                print("Wire.CrossShape - Error: The c input parameter must be less than the width minus half the a input parameter. Returning None.")
+                print("Face.CrossShape - Error: The c input parameter must be less than the width minus half the a input parameter. Returning None.")
             return None
         if d >= (length - tolerance - b/2):
             if not silent:
-                print("Wire.CrossShape - Error: The c input parameter must be less than the width minus half the b input parameter. Returning None.")
+                print("Face.CrossShape - Error: The c input parameter must be less than the width minus half the b input parameter. Returning None.")
             return None
         if origin == None:
             origin = Vertex.Origin()
         if not Topology.IsInstance(origin, "vertex"):
             if not silent:
-                print("Wire.CrossShape - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
+                print("Face.CrossShape - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
             return None
         if not isinstance(direction, list):
             if not silent:
-                print("Wire.CrossShape - Error: The direction input parameter is not a valid list. Returning None.")
+                print("Face.CrossShape - Error: The direction input parameter is not a valid list. Returning None.")
             return None
         if not len(direction) == 3:
             if not silent:
-                print("Wire.CrossShape - Error: The direction input parameter is not a valid vector. Returning None.")
+                print("Face.CrossShape - Error: The direction input parameter is not a valid vector. Returning None.")
             return None
         cross_shape_wire = Wire.CrossShape(origin=origin,
                                    width=width,
@@ -1663,7 +1684,7 @@ class Face():
         return True
 
     @staticmethod
-    def Fillet(face, radius: float = 0, radiusKey: str = None, tolerance: float = 0.0001, silent: bool = False):
+    def Fillet(face, radius: float = 0, sides: int = 16, radiusKey: str = None, tolerance: float = 0.0001, silent: bool = False):
         """
         Fillets (rounds) the interior and exterior corners of the input face given the input radius. See https://en.wikipedia.org/wiki/Fillet_(mechanics)
 
@@ -1671,8 +1692,10 @@ class Face():
         ----------
         face : topologic_core.Face
             The input face.
-        radius : float
-            The desired radius of the fillet.
+        radius : float , optional
+            The desired radius of the fillet. The default is 0.
+        sides : int , optional
+            The number of sides (segments) of the fillet. The default is 16.
         radiusKey : str , optional
             If specified, the dictionary of the vertices will be queried for this key to specify the desired fillet radius. The default is None.
         tolerance : float , optional
@@ -1700,19 +1723,19 @@ class Face():
         f_vertices = Topology.Vertices(face)
         if isinstance(radiusKey, str):
             eb = Topology.TransferDictionariesBySelectors(eb, selectors=f_vertices, tranVertices=True)
-        eb = Wire.Fillet(eb, radius=radius, radiusKey=radiusKey, tolerance=tolerance)
+        eb = Wire.Fillet(eb, radius=radius, sides=sides, radiusKey=radiusKey, tolerance=tolerance, silent=True)
         if not Topology.IsInstance(eb, "Wire"):
             if not silent:
                 print("Face.Fillet - Error: The operation failed. Returning None.")
             return None
         ib_wires = []
         for ib in ib_list:
-            ib = Wire.ByVertices(Topology.Vertices(ib))
+            ib = Wire.ByVertices(Topology.Vertices(ib), close=True, tolerance=tolerance, silent=silent)
             ib = Wire.Reverse(ib)
             if isinstance(radiusKey, str):
                 ib = Topology.TransferDictionariesBySelectors(ib, selectors=f_vertices, tranVertices=True)
             
-            ib_wire = Wire.Fillet(ib, radius=radius, radiusKey=radiusKey, tolerance=tolerance, silent=silent)
+            ib_wire = Wire.Fillet(ib, radius=radius, sides=sides, radiusKey=radiusKey, tolerance=tolerance, silent=True)
             if Topology.IsInstance(ib, "Wire"):
                 ib_wires.append(ib_wire)
             else:
@@ -1721,7 +1744,7 @@ class Face():
         return Face.ByWires(eb, ib_wires)
 
     @staticmethod
-    def Harmonize(face, tolerance: float = 0.0001):
+    def Harmonize(face, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns a harmonized version of the input face such that the *u* and *v* origins are always in the upperleft corner.
 
@@ -1731,6 +1754,8 @@ class Face():
             The input face.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1744,19 +1769,20 @@ class Face():
         from topologicpy.Dictionary import Dictionary
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.Harmonize - Error: The input face parameter is not a valid face. Returning None.")
+            if not silent:
+                print("Face.Harmonize - Error: The input face parameter is not a valid face. Returning None.")
             return None
         normal = Face.Normal(face)
         origin = Topology.Centroid(face)
         flatFace = Topology.Flatten(face, origin=origin, direction=normal)
         world_origin = Vertex.Origin()
         vertices = Topology.Vertices(Face.ExternalBoundary(flatFace))
-        harmonizedEB = Wire.ByVertices(vertices)
+        harmonizedEB = Wire.ByVertices(vertices, close=True, tolerance=tolerance, silent=silent)
         internalBoundaries = Face.InternalBoundaries(flatFace)
         harmonizedIB = []
         for ib in internalBoundaries:
             ibVertices = Topology.Vertices(ib)
-            harmonizedIB.append(Wire.ByVertices(ibVertices))
+            harmonizedIB.append(Wire.ByVertices(ibVertices, close=True, tolerance=tolerance, silent=silent))
         harmonizedFace = Face.ByWires(harmonizedEB, harmonizedIB, tolerance=tolerance)
         harmonizedFace = Topology.Unflatten(harmonizedFace, origin=origin, direction=normal)
         return harmonizedFace
@@ -1895,7 +1921,7 @@ class Face():
         return vert
 
     @staticmethod
-    def Invert(face, tolerance: float = 0.0001):
+    def Invert(face, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a face that is an inverse (mirror) of the input face.
 
@@ -1905,6 +1931,8 @@ class Face():
             The input face.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1920,12 +1948,12 @@ class Face():
         eb = Face.ExternalBoundary(face)
         vertices = Topology.Vertices(eb)
         vertices.reverse()
-        inverted_wire = Wire.ByVertices(vertices)
+        inverted_wire = Wire.ByVertices(vertices, close=Wire.IsClosed(eb), tolerance=tolerance, silent=silent)
         internal_boundaries = Face.InternalBoundaries(face)
         if not internal_boundaries:
-            inverted_face = Face.ByWire(inverted_wire, tolerance=tolerance)
+            inverted_face = Face.ByWire(inverted_wire, tolerance=tolerance, silent=silent)
         else:
-            inverted_face = Face.ByWires(inverted_wire, internal_boundaries, tolerance=tolerance)
+            inverted_face = Face.ByWires(inverted_wire, internal_boundaries, tolerance=tolerance, silent=silent)
         return inverted_face
     @staticmethod
     def IsConvex(face, mantissa: int = 6, silent: bool = False) -> bool:
@@ -2140,7 +2168,7 @@ class Face():
         return Face.ByWire(i_shape_wire, tolerance=tolerance, silent=silent)
 
     @staticmethod
-    def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, transferDictionaries: bool = False, metrics: bool = False, triangles: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
+    def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, transferDictionaries: bool = False, metrics: bool = False, triangles: bool = False, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the face representing the isovist projection from the input viewpoint.
         This method assumes all input is in 2D. Z coordinates are ignored.
@@ -2199,6 +2227,8 @@ class Face():
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional:
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -2481,7 +2511,7 @@ class Face():
         vertices = Topology.Vertices(eb)
         coords = [Vertex.Coordinates(v, outputType="xy") for v in vertices]
         new_vertices = [Vertex.ByCoordinates(coord) for coord in coords]
-        eb = Wire.ByVertices(new_vertices, close=True)
+        eb = Wire.ByVertices(new_vertices, close=True, tolerance=tolerance, silent=silent)
 
         ib_list = Face.InternalBoundaries(flat_face)
         new_ib_list = []
@@ -2489,7 +2519,7 @@ class Face():
             vertices = Topology.Vertices(ib)
             coords = [Vertex.Coordinates(v, outputType="xy") for v in vertices]
             new_vertices = [Vertex.ByCoordinates(coord) for coord in coords]
-            new_ib_list.append(Wire.ByVertices(new_vertices, close=True))
+            new_ib_list.append(Wire.ByVertices(new_vertices, close=True, tolerance=tolerance, silent=silent))
 
         flat_face = Face.ByWires(eb, new_ib_list)
         for obs in flat_obstacles:
@@ -2508,7 +2538,7 @@ class Face():
         edges = []
         for target in targets:
             if Vertex.Distance(flat_vertex, target) > tolerance:
-                e = Edge.ByVertices(flat_vertex, target, silent=True)
+                e = Edge.ByVertices([flat_vertex, target], tolerance=tolerance, silent=True)
                 e = Edge.SetLength(e, length=max_d, bothSides=False, tolerance=tolerance)
                 edges.append(e)
         shell = Topology.Slice(flat_face, Cluster.ByTopologies(edges))
@@ -2533,11 +2563,12 @@ class Face():
                     sv = vertices[Vertex.Index(Edge.StartVertex(edge), vertices, tolerance=0.01)]
                     ev = vertices[Vertex.Index(Edge.EndVertex(edge), vertices, tolerance=0.01)]
                     if Vertex.Distance(sv, ev) > tolerance:
-                        new_edges.append(Edge.ByVertices([sv,ev]))
+                        new_edges.append(Edge.ByVertices([sv,ev], tolerance=tolerance, silent=True))
                 w = Wire.ByEdges(new_edges, tolerance=0.01)
                 return_face = Face.ByWire(w)
             if not Topology.IsInstance(return_face, "Face"):
-                print("Face.Isovist - Error: Could not create isovist. Returning None.")
+                if not silent:
+                    print("Face.Isovist - Error: Could not create isovist. Returning None.")
                 return None 
         compAngle = 0
         if fov == 360:
@@ -2555,9 +2586,10 @@ class Face():
         if not Topology.IsInstance(return_face, "face"):
             return_face = Topology.SelfMerge(return_face)
         if return_face == None:
-            print("Face.Isovist - Error: Could not create isovist. Returning None.")
+            if not silent:
+                print("Face.Isovist - Error: Could not create isovist. Returning None.")
             return None
-        simpler_face = Face.RemoveCollinearEdges(return_face)
+        simpler_face = Face.RemoveCollinearEdges(return_face, angTolerance=0.1, tolerance=tolerance, silent=silent)
         if Topology.IsInstance(simpler_face, "face"):
             if transferDictionaries == True or metrics == True:
                 j_edges = [Topology.Edges(t) for t in obstacles]
@@ -2729,10 +2761,10 @@ class Face():
             edges = Topology.Edges(return_face)
             for edge in edges:
                 d = Topology.Dictionary(edge)
-                if Vertex.Distance(Edge.StartVertex(edge), v) > 0.0001:
-                    e1 = Edge.ByVertices(Edge.StartVertex(edge), v)
-                    if Vertex.Distance(Edge.EndVertex(edge), v) > 0.0001:
-                        e2 = Edge.ByVertices(Edge.EndVertex(edge), v)
+                if Vertex.Distance(Edge.StartVertex(edge), v) > tolerance:
+                    e1 = Edge.ByVertices([Edge.StartVertex(edge), v], tolerance=tolerance, silent=True)
+                    if Vertex.Distance(Edge.EndVertex(edge), v) > tolerance:
+                        e2 = Edge.ByVertices([Edge.EndVertex(edge), v], tolerance=tolerance, silent=True)
                         triangle = Topology.SelfMerge(Cluster.ByTopologies(edge, e1, e2))
                         if Topology.IsInstance(triangle, "wire"):
                             if Wire.IsClosed(triangle):
@@ -2863,7 +2895,7 @@ class Face():
         return Face.ByWire(l_shape_wire, tolerance=tolerance, silent=silent)
 
     @staticmethod
-    def MedialAxis(face, resolution: int = 0, externalVertices: bool = False, internalVertices: bool = False, toLeavesOnly: bool = False, angTolerance: float = 0.1, tolerance: float = 0.0001):
+    def MedialAxis(face, resolution: int = 0, externalVertices: bool = False, internalVertices: bool = False, toLeavesOnly: bool = False, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns a wire representing an approximation of the medial axis of the input topology. See https://en.wikipedia.org/wiki/Medial_axis.
 
@@ -2883,6 +2915,8 @@ class Face():
             The desired angular tolerance in degrees for removing collinear edges. The default is 0.1.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
@@ -2953,7 +2987,7 @@ class Face():
 
         tempWire = Topology.SelfMerge(Cluster.ByTopologies(medialAxisEdges), tolerance=tolerance)
         if Topology.IsInstance(tempWire, "Wire") and angTolerance > 0:
-            tempWire = Wire.RemoveCollinearEdges(tempWire, angTolerance=angTolerance)
+            tempWire = Wire.RemoveCollinearEdges(tempWire, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
         medialAxisEdges = Wire.Edges(tempWire)
         for v in theVertices:
             nv = Vertex.NearestVertex(v, tempWire, useKDTree=False)
@@ -2962,12 +2996,12 @@ class Face():
                 if toLeavesOnly:
                     adjVertices = Topology.AdjacentTopologies(nv, tempWire)
                     if len(adjVertices) < 2:
-                        medialAxisEdges.append(Edge.ByVertices([nv, v], tolerance=tolerance))
+                        medialAxisEdges.append(Edge.ByVertices([nv, v], tolerance=tolerance, silent=silent))
                 else:
-                    medialAxisEdges.append(Edge.ByVertices([nv, v], tolerance=tolerance))
+                    medialAxisEdges.append(Edge.ByVertices([nv, v], tolerance=tolerance, silent=silent))
         medialAxis = Topology.SelfMerge(Cluster.ByTopologies(medialAxisEdges), tolerance=tolerance)
         if Topology.IsInstance(medialAxis, "Wire") and angTolerance > 0:
-            medialAxis = Topology.RemoveCollinearEdges(medialAxis, angTolerance=angTolerance)
+            medialAxis = Topology.RemoveCollinearEdges(medialAxis, angTolerance=angTolerance, tolerance=tolerance, silent=silent)
         medialAxis = Topology.Unflatten(medialAxis, origin=origin,direction=normal)
         return medialAxis
 
@@ -3114,6 +3148,57 @@ class Face():
         ev = Topology.TranslateByDirectionDistance(iv, vec, length)
         return Edge.ByVertices([iv, ev], tolerance=tolerance, silent=silent)
 
+    @staticmethod
+    def NorthArrow(origin= None, radius: float = 0.5, sides: int = 16, direction: list = [0, 0, 1], northAngle: float = 0.0,
+                   placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates a north arrow.
+
+        Parameters
+        ----------
+        origin : topologic_core.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).
+        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].
+        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
+            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
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Face
+            The created circle.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Vertex import Vertex
+        if not Topology.IsInstance(origin, "Vertex"):
+            origin = Vertex.Origin()
+        
+        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, origin=Vertex.Origin(), axis=[0, 0, 1], angle=northAngle)
+        if placement.lower() == "lowerleft":
+            arrow = Topology.Translate(arrow, radius, radius, 0)
+        elif placement.lower() == "upperleft":
+            arrow = Topology.Translate(arrow, radius, -radius, 0)
+        elif placement.lower() == "lowerright":
+            arrow = Topology.Translate(arrow, -radius, radius, 0)
+        elif placement.lower() == "upperright":
+            arrow = Topology.Translate(arrow, -radius, -radius, 0)
+        arrow = Topology.Place(arrow, originA=Vertex.Origin(), originB=origin)
+        arrow = Topology.Orient(arrow, origin=origin, dirA=[0,0,1], dirB=direction)
+        return arrow
+    
     @staticmethod
     def PlaneEquation(face, mantissa: int = 6) -> dict:
         """
@@ -3281,7 +3366,7 @@ class Face():
         return Face.ByWire(wire, tolerance=tolerance)
     
     @staticmethod
-    def RemoveCollinearEdges(face, angTolerance: float = 0.1, tolerance: float = 0.0001):
+    def RemoveCollinearEdges(face, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Removes any collinear edges in the input face.
 
@@ -3293,6 +3378,8 @@ class Face():
             The desired angular tolerance. The default is 0.1.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -3305,15 +3392,211 @@ class Face():
         import inspect
         
         if not Topology.IsInstance(face, "Face"):
-            print("Face.RemoveCollinearEdges - Error: The input face parameter is not a valid face. Returning None.")
-            curframe = inspect.currentframe()
-            calframe = inspect.getouterframes(curframe, 2)
-            print('caller name:', calframe[1][3])
+            if not silent:
+                print("Face.RemoveCollinearEdges - Error: The input face parameter is not a valid face. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
-        eb = Wire.RemoveCollinearEdges(Face.Wire(face), angTolerance=angTolerance, tolerance=tolerance)
-        ib = [Wire.RemoveCollinearEdges(w, angTolerance=angTolerance, tolerance=tolerance) for w in Face.InternalBoundaries(face)]
+        eb = Wire.RemoveCollinearEdges(Face.Wire(face), angTolerance=angTolerance, tolerance=tolerance, silent=silent)
+        ib = [Wire.RemoveCollinearEdges(w, angTolerance=angTolerance, tolerance=tolerance, silent=silent) for w in Face.InternalBoundaries(face)]
         return Face.ByWires(eb, ib)
     
+    @staticmethod
+    def RHS(origin= None, width: float = 1.0, length: float = 1.0, thickness: float = 0.25, outerFillet: float = 0.0, innerFillet: float = 0.0, sides: int = 16, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a rectangluar hollow section (RHS).
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex, optional
+            The location of the origin of the RHS. The default is None which results in the RHS being placed at (0, 0, 0).
+        width : float , optional
+            The width of the RHS. The default is 1.0.
+        length : float , optional
+            The length of the RHS. The default is 1.0.
+        thickness : float , optional
+            The thickness of the RHS. The default is 0.25.
+        outerFillet : float , optional
+            The outer fillet multiplication factor based on the thickness (e.g. 1t). The default is 0.
+        innerFillet : float , optional
+            The inner fillet multiplication factor based on the thickness (e.g. 1.5t). The default is 0.
+        sides : int , optional
+            The desired number of sides of the fillets. The default is 16.
+        direction : list , optional
+            The vector representing the up direction of the RHS. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the RHS. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Face
+            The created face.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if 2*thickness >= width:
+            if not silent:
+                print("Face.RHS - Error: Twice the thickness value is larger than or equal to the width value. Returning None.")
+            return None
+        if 2*thickness >= width:
+            if not silent:
+                print("Face.RHS - Error: Twice the thickness value is larger than or equal to the length value. Returning None.")
+            return None
+        outer_dimension = min(width, length)
+        fillet_dimension = 2*outerFillet*thickness
+        if  fillet_dimension > outer_dimension:
+            if not silent:
+                print("Face.RHS = Error: The outer fillet radius input value is too large given the desired dimensions of the RHS. Returning None.")
+            return None
+        inner_dimension = min(width, length) - 2*thickness
+        fillet_dimension = 2*innerFillet*thickness
+        if fillet_dimension > inner_dimension:
+            if not silent:
+                print("Face.RHS = Error: The inner fillet radius input value is too large given the desired dimensions of the RHS. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        
+        outer_wire = Wire.Rectangle(origin=Vertex.Origin(), width=width, length=length, direction=[0,0,1], placement="center", tolerance=tolerance, silent=silent)
+        inner_wire = Wire.Rectangle(origin=Vertex.Origin(), width=width-thickness*2, length=length-thickness*2, direction=[0,0,1], placement="center", tolerance=tolerance, silent=silent)
+        if outerFillet > 0:
+           outer_wire = Wire.Fillet(outer_wire, radius=outerFillet*thickness, sides=sides, silent=silent)
+        if innerFillet > 0:
+           inner_wire = Wire.Fillet(inner_wire, radius=innerFillet*thickness, sides=sides, silent=silent) 
+        return_face = Face.ByWires(outer_wire, [inner_wire], silent=silent)
+        if not Topology.IsInstance(return_face, "face"):
+            if not silent:
+                print("Face.RHS - Error: Could not create the face for the RHS. Returning None.")
+            return None
+        
+        xOffset = 0
+        yOffset = 0
+        zOffset = 0
+        if placement.lower() == "lowerleft":
+            xOffset = width*0.5
+            yOffset = length*0.5
+        elif placement.lower() == "upperleft":
+            xOffset = width*0.5
+            yOffset = -length*0.5
+        elif placement.lower() == "lowerright":
+            xOffset = -width*0.5
+            yOffset = length*0.5
+        elif placement.lower() == "upperright":
+            xOffset = -width*0.5
+            yOffset = -length*0.5
+        return_face = Topology.Translate(return_face, x=xOffset, y=yOffset, z=zOffset)
+        return_face = Topology.Place(return_face, originA=Vertex.Origin(), originB=origin)
+        if direction != [0, 0, 1]:
+            return_face = Topology.Orient(return_face, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return return_face
+    
+    @staticmethod
+    def Ring(origin= None, radius: float = 0.5, thickness: float = 0.25, sides: int = 16, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a circular ring. This is an alias method for creating a circular hollow section (CHS).
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex, optional
+            The location of the origin of the ring. The default is None which results in the ring being placed at (0, 0, 0).
+        radius : float , optional
+            The outer radius of the ring. The default is 0.5.
+        thickness : float , optional
+            The thickness of the ring. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the ring. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the ring. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Face
+            The created face.
+
+        """
+        
+        if thickness >= radius:
+            if not silent:
+                print("Face.Ring - Error: The thickness value is larger than or equal to the outer radius value. Returning None.")
+            return None
+        return Face.CHS(origin=origin,
+                        radius=radius,
+                        thickness=thickness,
+                        sides=sides,
+                        direction=direction,
+                        placement=placement,
+                        tolerance=tolerance,
+                        silent=silent)
+    @staticmethod
+    def SHS(origin= None, size: float = 1.0, thickness: float = 0.25, outerFillet: float = 0.0, innerFillet: float = 0.0, sides: int = 16, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a square hollow section (SHS).
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex, optional
+            The location of the origin of the SHS. The default is None which results in the SHS being placed at (0, 0, 0).
+        size : float , optional
+            The outer size of the SHS. The default is 1.0.
+        thickness : float , optional
+            The thickness of the SHS. The default is 0.25.
+        outerFillet : float , optional
+            The outer fillet multiplication factor based on the thickness (e.g. 1t). The default is 0.
+        innerFillet : float , optional
+            The inner fillet multiplication factor based on the thickness (e.g. 1.5t). The default is 0.
+        sides : int , optional
+            The desired number of sides of the fillets. The default is 16.
+        direction : list , optional
+            The vector representing the up direction of the SHS. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the SHS. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Face
+            The created face.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+        
+        if 2*thickness >= size:
+            if not silent:
+                print("Face.SHS - Error: Twice the thickness value is larger than or equal to the outer size value. Returning None.")
+            return None
+        fillet_dimension = 2*outerFillet*thickness
+        if  fillet_dimension > size:
+            if not silent:
+                print("Face.RHS = Error: The outer fillet radius input value is too large given the desired dimensions of the RHS. Returning None.")
+            return None
+        inner_dimension = size - 2*thickness
+        fillet_dimension = 2*innerFillet*thickness
+        if fillet_dimension > inner_dimension:
+            if not silent:
+                print("Face.RHS = Error: The inner fillet radius input value is too large given the desired dimensions of the RHS. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        
+        return Face.RHS(origin = origin, width = size, length = size, thickness = thickness, outerFillet = outerFillet, innerFillet = innerFillet, sides = sides, direction = direction, placement = placement, tolerance = tolerance, silent = silent)
+    
     @staticmethod
     def Simplify(face, tolerance=0.0001):
         """