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

topologicpy/Wire.py

@@ -982,9 +982,9 @@ class Wire():
         sides = int(math.floor(sides))
         for i in range(sides+1):
             angle = fromAngle + math.radians(angleRange/sides)*i
-            x = math.sin(angle)*radius + origin.X()
-            y = math.cos(angle)*radius + origin.Y()
-            z = origin.Z()
+            x = math.sin(angle)*radius + Vertex.X(origin)
+            y = math.cos(angle)*radius + Vertex.Y(origin)
+            z = Vertex.Z(origin)
             xList.append(x)
             yList.append(y)
             baseV.append(Vertex.ByCoordinates(x, y, z))
@@ -1421,6 +1421,157 @@ class Wire():
         ch = Topology.Unflatten(ch, origin=origin, direction=normal)
         return ch
 
+
+    @staticmethod
+    def CShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            c =0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates a C-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the C-shape. The default is None which results in the C-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the C-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the C-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the C-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the lower horizontal arm of the C-shape. The default is 0.25.
+        c : float , optional
+            The vertical thickness of the upper horizontal arm of the C-shape. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the C-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the C-shape. 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.Wire
+            The created C-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Wire.CShape - 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.CShape - 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.CShape - 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.CShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Wire.CShape - 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.CShape - 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.CShape - 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.CShape - 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.CShape - Error: The c input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Wire.CShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b+c >= (length - tolerance):
+            if not silent:
+                print("Wire.CShape - Error: The b and c input parameters must add to less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Wire.CShape - 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.CShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Wire.CShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        
+        # Define the vertices of the C-shape (counterclockwise)
+        v1 = Vertex.Origin()  # Base origin
+        v2 = Vertex.ByCoordinates(width, 0)
+        v3 = Vertex.ByCoordinates(width, b)
+        v4 = Vertex.ByCoordinates(a, b)
+        v5 = Vertex.ByCoordinates(a, length-c)
+        v6 = Vertex.ByCoordinates(width, length-c)
+        v7 = Vertex.ByCoordinates(width, length)
+        v8 = Vertex.ByCoordinates(0, length)
+
+        # Create the C-shaped wire
+        c_shape = Wire.ByVertices([v1, v2, v3, v4, v5, v6, v7, v8], close=True)
+        c_shape = Topology.Translate(c_shape, -width/2, -length/2, 0)
+        c_shape = Topology.Translate(c_shape, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+        reverse = False
+        if flipHorizontal == True:
+            xScale = -1
+            reverse = not reverse
+        else:
+            xScale = 1
+        if flipVertical == True:
+            yScale = -1
+            reverse = not reverse
+        else:
+            yScale = 1
+        if xScale == -1 or yScale == -1:
+            c_shape = Topology.Scale(c_shape, x=xScale, y=yScale, z=1)
+            if reverse == True:
+                c_shape = Wire.Reverse(c_shape)
+        if placement.lower() == "lowerleft":
+            c_shape = Topology.Translate(c_shape, width/2, length/2, 0)
+        elif placement.lower() == "upperright":
+            c_shape = Topology.Translate(c_shape, -width/2, -length/2, 0)
+        elif placement.lower() == "upperleft":
+            c_shape = Topology.Translate(c_shape, width/2, -length/2, 0)
+        elif placement.lower() == "lowerright":
+            c_shape = Topology.Translate(c_shape, -width/2, length/2, 0)
+        
+        if direction != [0, 0, 1]:
+            c_shape = Topology.Orient(c_shape, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return c_shape
+
     @staticmethod
     def Cycles(wire, maxVertices: int = 4, tolerance: float = 0.0001) -> list:
         """
@@ -1512,7 +1663,7 @@ class Wire():
 
         graph = []
         for anEdge in tEdges:
-            graph.append([vIndex(anEdge.StartVertex(), tVertices, tolerance), vIndex(anEdge.EndVertex(), tVertices, tolerance)]) # Hook to Core
+            graph.append([vIndex(Edge.StartVertex(anEdge), tVertices, tolerance), vIndex(Edge.EndVertex(anEdge), tVertices, tolerance)]) # Hook to Core
 
         cycles = []
         resultingCycles = main(graph, cycles, maxVertices)
@@ -1801,9 +1952,9 @@ class Wire():
         sides = int(math.floor(sides))
         for i in range(sides+1):
             angle = fromAngle + math.radians(angleRange/sides)*i
-            x = math.sin(angle)*a + origin.X()
-            y = math.cos(angle)*b + origin.Y()
-            z = origin.Z()
+            x = math.sin(angle)*a + Vertex.X(origin)
+            y = math.cos(angle)*b + Vertex.Y(origin)
+            z = Vertex.Z(origin)
             xList.append(x)
             yList.append(y)
             baseV.append(Vertex.ByCoordinates(x, y, z))
@@ -1817,8 +1968,8 @@ class Wire():
             baseWire = Topology.Translate(baseWire, a, b, 0)
         baseWire = Topology.Orient(baseWire, origin=origin, dirA=[0, 0, 1], dirB=direction)
         # Create a Cluster of the two foci
-        v1 = Vertex.ByCoordinates(c+origin.X(), 0+origin.Y(), 0)
-        v2 = Vertex.ByCoordinates(-c+origin.X(), 0+origin.Y(), 0)
+        v1 = Vertex.ByCoordinates(c+Vertex.X(origin), 0+Vertex.Y(origin), 0)
+        v2 = Vertex.ByCoordinates(-c+Vertex.X(origin), 0+Vertex.Y(origin), 0)
         foci = Cluster.ByTopologies([v1, v2])
         if placement.lower() == "lowerleft":
             foci = Topology.Translate(foci, a, b, 0)
@@ -2332,18 +2483,18 @@ class Wire():
             return False
 
         def angleBetweenEdges(e1, e2, tolerance=0.0001):
-            a = e1.EndVertex().X() - e1.StartVertex().X()
-            b = e1.EndVertex().Y() - e1.StartVertex().Y()
-            c = e1.EndVertex().Z() - e1.StartVertex().Z()
-            d = Vertex.Distance(e1.EndVertex(), e2.StartVertex())
+            a = Vertex.X(Edge.EndVertex(e1)) - Vertex.X(Edge.StartVertex(e1))
+            b = Vertex.Y(Edge.EndVertex(e1)) - Vertex.Y(Edge.StartVertex(e1))
+            c = Vertex.Z(Edge.EndVertex(e1)) - Vertex.Z(Edge.StartVertex(e1))
+            d = Vertex.Distance(Edge.EndVertex(e1), Edge.StartVertex(e2))
             if d <= tolerance:
-                d = e2.StartVertex().X() - e2.EndVertex().X()
-                e = e2.StartVertex().Y() - e2.EndVertex().Y()
-                f = e2.StartVertex().Z() - e2.EndVertex().Z()
+                d = Vertex.X(Edge.StartVertex(e2)) - Vertex.X(Edge.EndVertex(e2))
+                e = Vertex.Y(Edge.StartVertex(e2)) - Vertex.Y(Edge.EndVertex(e2))
+                f = Vertex.Z(Edge.StartVertex(e2)) - Vertex.Z(Edge.EndVertex(e2))
             else:
-                d = e2.EndVertex().X() - e2.StartVertex().X()
-                e = e2.EndVertex().Y() - e2.StartVertex().Y()
-                f = e2.EndVertex().Z() - e2.StartVertex().Z()
+                d = Vertex.X(Edge.EndVertex(e2)) - Vertex.X(Edge.StartVertex(e2))
+                e = Vertex.Y(Edge.EndVertex(e2)) - Vertex.Y(Edge.StartVertex(e2))
+                f = Vertex.Z(Edge.EndVertex(e2)) - Vertex.Z(Edge.StartVertex(e2))
             dotProduct = a*d + b*e + c*f
             modOfVector1 = math.sqrt( a*a + b*b + c*c)*math.sqrt(d*d + e*e + f*f) 
             angle = dotProduct/modOfVector1
@@ -2387,6 +2538,160 @@ class Wire():
             return True
         return False
 
+    @staticmethod
+    def IShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            c =0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates an I-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the I-shape. The default is None which results in the I-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the I-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the I-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the central vertical arm of the I-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the lower horizontal arm of the I-shape. The default is 0.25.
+        c : float , optional
+            The vertical thickness of the upper horizontal arm of the I-shape. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the I-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the I-shape. 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.Wire
+            The created I-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Wire.IShape - 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.IShape - 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.IShape - 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.IShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Wire.IShape - 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.IShape - 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.IShape - 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.IShape - 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.IShape - Error: The c input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Wire.IShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b+c >= (length - tolerance):
+            if not silent:
+                print("Wire.IShape - Error: The b and c input parameters must add to less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Wire.IShape - 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.IShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Wire.IShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        
+        # Define the vertices of the I-shape (counterclockwise)
+        v1 = Vertex.Origin()  # Base origin
+        v2 = Vertex.ByCoordinates(width, 0)
+        v3 = Vertex.ByCoordinates(width, b)
+        v4 = Vertex.ByCoordinates(width/2+a/2, b)
+        v5 = Vertex.ByCoordinates(width/2+a/2, length-c)
+        v6 = Vertex.ByCoordinates(width, length-c)
+        v7 = Vertex.ByCoordinates(width, length)
+        v8 = Vertex.ByCoordinates(0, length)
+        v9 = Vertex.ByCoordinates(0, length-c)
+        v10 = Vertex.ByCoordinates(width/2-a/2, length-c)
+        v11 = Vertex.ByCoordinates(width/2-a/2, b)
+        v12 = Vertex.ByCoordinates(0,b)
+
+        # Create the I-shaped wire
+        i_shape = Wire.ByVertices([v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12], close=True)
+        i_shape = Topology.Translate(i_shape, -width/2, -length/2, 0)
+        i_shape = Topology.Translate(i_shape, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+        reverse = False
+        if flipHorizontal == True:
+            xScale = -1
+            reverse = not reverse
+        else:
+            xScale = 1
+        if flipVertical == True:
+            yScale = -1
+            reverse = not reverse
+        else:
+            yScale = 1
+        if xScale == -1 or yScale == -1:
+            i_shape = Topology.Scale(i_shape, x=xScale, y=yScale, z=1)
+            if reverse == True:
+                i_shape = Wire.Reverse(i_shape)
+        if placement.lower() == "lowerleft":
+            i_shape = Topology.Translate(i_shape, width/2, length/2, 0)
+        elif placement.lower() == "upperright":
+            i_shape = Topology.Translate(i_shape, -width/2, -length/2, 0)
+        elif placement.lower() == "upperleft":
+            i_shape = Topology.Translate(i_shape, width/2, -length/2, 0)
+        elif placement.lower() == "lowerright":
+            i_shape = Topology.Translate(i_shape, -width/2, length/2, 0)
+        
+        if direction != [0, 0, 1]:
+            i_shape = Topology.Orient(i_shape, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return i_shape
+
     @staticmethod
     def Length(wire, mantissa: int = 6) -> float:
         """
@@ -2480,7 +2785,148 @@ class Wire():
             vertices.append(Edge.VertexByParameter(edge, i*unitDistance))
         vertices.append(Edge.EndVertex(edge))
         return Wire.ByVertices(vertices)
-    
+
+    @staticmethod
+    def LShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates an L-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the L-shape. The default is None which results in the L-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the L-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the L-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the L-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the horizontal arm of the L-shape. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the L-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the L-shape. 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.Wire
+            The created L-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Wire.LShape - 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.LShape - 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.LShape - 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.LShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Wire.LShape - 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.LShape - 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.LShape - 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.LShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Wire.LShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b >= (length - tolerance):
+            if not silent:
+                print("Wire.LShape - Error: The b input parameter must be less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Wire.LShape - 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.LShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Wire.LShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        
+        # Define the vertices of the L-shape (counterclockwise)
+        v1 = Vertex.Origin()  # Base origin
+        v2 = Vertex.ByCoordinates(width, 0)  # End of horizontal arm
+        v3 = Vertex.ByCoordinates(width, b)  # Top of horizontal arm
+        v4 = Vertex.ByCoordinates(a, b)  # Transition to vertical arm
+        v5 = Vertex.ByCoordinates(a, length)  # End of vertical arm
+        v6 = Vertex.ByCoordinates(0, length)  # Top of vertical arm
+
+        # Create the L-shaped wire
+        l_shape = Wire.ByVertices([v1, v2, v3, v4, v5, v6], close=True)
+        l_shape = Topology.Translate(l_shape, -width/2, -length/2, 0)
+        l_shape = Topology.Translate(l_shape, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+        reverse = False
+        if flipHorizontal == True:
+            xScale = -1
+            reverse = not reverse
+        else:
+            xScale = 1
+        if flipVertical == True:
+            yScale = -1
+            reverse = not reverse
+        else:
+            yScale = 1
+        if xScale == -1 or yScale == -1:
+            l_shape = Topology.Scale(l_shape, x=xScale, y=yScale, z=1)
+            if reverse == True:
+                l_shape = Wire.Reverse(l_shape)
+        if placement.lower() == "lowerleft":
+            l_shape = Topology.Translate(l_shape, width/2, length/2, 0)
+        elif placement.lower() == "upperright":
+            l_shape = Topology.Translate(l_shape, -width/2, -length/2, 0)
+        elif placement.lower() == "upperleft":
+            l_shape = Topology.Translate(l_shape, width/2, -length/2, 0)
+        elif placement.lower() == "lowerright":
+            l_shape = Topology.Translate(l_shape, -width/2, length/2, 0)
+        
+        if direction != [0, 0, 1]:
+            l_shape = Topology.Orient(l_shape, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return l_shape
+
     @staticmethod
     def Miter(wire, offset: float = 0, offsetKey: str = None, tolerance: float = 0.0001, silent: bool = False):
         """
@@ -2871,7 +3317,7 @@ class Wire():
             return None
         if not direction:
             direction = -1*Face.Normal(face, outputType="xyz", mantissa=mantissa)
-        large_face = Topology.Scale(face, face.CenterOfMass(), 500, 500, 500)
+        large_face = Topology.Scale(face, Topology.CenterOfMass(face), 500, 500, 500)
         edges = []
         _ = wire.Edges(None, edges)
         projected_edges = []
@@ -2881,8 +3327,8 @@ class Wire():
                 for edge in edges:
                     if edge:
                         if (Topology.Type(edge) == Topology.TypeID("Edge")):
-                            sv = edge.StartVertex()
-                            ev = edge.EndVertex()
+                            sv = Edge.StartVertex(edge)
+                            ev = Edge.EndVertex(edge)
 
                             psv = Vertex.Project(vertex=sv, face=large_face, direction=direction)
                             pev = Vertex.Project(vertex=ev, face=large_face, direction=direction)
@@ -2957,10 +3403,10 @@ class Wire():
             xOffset = -width*0.5
             yOffset = -length*0.5
 
-        vb1 = Vertex.ByCoordinates(origin.X()-width*0.5+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb2 = Vertex.ByCoordinates(origin.X()+width*0.5+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb3 = Vertex.ByCoordinates(origin.X()+width*0.5+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
-        vb4 = Vertex.ByCoordinates(origin.X()-width*0.5+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
+        vb1 = Vertex.ByCoordinates(Vertex.X(origin)-width*0.5+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb2 = Vertex.ByCoordinates(Vertex.X(origin)+width*0.5+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb3 = Vertex.ByCoordinates(Vertex.X(origin)+width*0.5+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
+        vb4 = Vertex.ByCoordinates(Vertex.X(origin)-width*0.5+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
 
         baseWire = Wire.ByVertices([vb1, vb2, vb3, vb4], True)
         if direction != [0, 0, 1]:
@@ -3181,6 +3627,88 @@ class Wire():
         else:
             return wire
     
+    @staticmethod
+    def Representation(wire, normalize: bool = True, rotate: bool = True, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Returns a normalized representation of a closed wire with alternating edge lengths and interior angles.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire.
+        normalize : bool , optional
+            If set to True, the lengths in the list are normalized so that the shortest edge has a length of 1. the default is True.
+        rotate : bool , optional
+            If set to True, the list is rotated such that the shortest edge appears first.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The representation list.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        import math
+
+        def angleBetweenEdges(e1, e2, tolerance=0.0001):
+            a = Vertex.X(Edge.EndVertex(e1)) - Vertex.X(Edge.StartVertex(e1))
+            b = Vertex.Y(Edge.EndVertex(e1)) - Vertex.Y(Edge.StartVertex(e1))
+            c = Vertex.Z(Edge.EndVertex(e1)) - Vertex.Z(Edge.StartVertex(e1))
+            d = Vertex.Distance(Edge.EndVertex(e1), Edge.StartVertex(e2))
+            if d <= tolerance:
+                d = Vertex.X(Edge.StartVertex(e2)) - Vertex.X(Edge.EndVertex(e2))
+                e = Vertex.Y(Edge.StartVertex(e2)) - Vertex.Y(Edge.EndVertex(e2))
+                f = Vertex.Z(Edge.StartVertex(e2)) - Vertex.Z(Edge.EndVertex(e2))
+            else:
+                d = Vertex.X(Edge.EndVertex(e2)) -  Vertex.X(Edge.StartVertex(e2))
+                e = Vertex.Y(Edge.EndVertex(e2)) - Vertex.Y(Edge.StartVertex(e2))
+                f = Vertex.Z(Edge.EndVertex(e2)) - Vertex.Z(Edge.StartVertex(e2))
+            dotProduct = a*d + b*e + c*f
+            modOfVector1 = math.sqrt( a*a + b*b + c*c)*math.sqrt(d*d + e*e + f*f) 
+            angle = dotProduct/modOfVector1
+            angleInDegrees = math.degrees(math.acos(angle))
+            return angleInDegrees
+
+        def getInteriorAngles(edges, tolerance=0.0001):
+            angles = []
+            for i in range(len(edges)-1):
+                e1 = edges[i]
+                e2 = edges[i+1]
+                angles.append(angleBetweenEdges(e1, e2, tolerance=tolerance))
+            return angles
+
+        def rotate_list_to_minimum(nums):
+            if not nums:
+                return nums  # Return the empty list as-is
+
+            min_index = nums.index(min(nums))
+            return nums[min_index:] + nums[:min_index]
+        
+        def getRep(edges, normalize=True, rotate=True, tolerance=0.0001):
+            angles = getInteriorAngles(edges, tolerance=tolerance)
+            lengths = []
+            normalizedLengths = []
+            for anEdge in edges:
+                lengths.append(Edge.Length(anEdge))
+            if normalize == True:
+                minLength = min(lengths)
+            else:
+                minLength = 1
+            for aLength in lengths:
+                normalizedLengths.append(aLength/minLength)
+            if rotate == True:
+                return rotate_list_to_minimum([x for x in itertools.chain(*itertools.zip_longest(normalizedLengths, angles)) if x is not None])
+            return [x for x in itertools.chain(*itertools.zip_longest(normalizedLengths, angles)) if x is not None]
+
+        edges = Topology.Edges(wire)
+        return_list = [round(x, mantissa) for x in getRep(edges, normalize=normalize, rotate=rotate, tolerance=tolerance)]
+        return return_list
+    
     @staticmethod
     def Reverse(wire, transferDictionaries = False, tolerance: float = 0.0001):
         """
@@ -3305,7 +3833,7 @@ class Wire():
             eb_vertices = Topology.Vertices(eb_wire)
             if normal[2] > 0:
                 eb_vertices = list(reversed(eb_vertices))
-            eb_polygon_coordinates = [(v.X(), v.Y(), v.Z()) for v in eb_vertices]
+            eb_polygon_coordinates = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in eb_vertices]
             eb_polygonxy = [(x[0], x[1]) for x in eb_polygon_coordinates]
 
             ib_polygonsxy = []
@@ -3314,7 +3842,7 @@ class Wire():
                 ib_vertices = Topology.Vertices(ib_wire)
                 if normal[2] > 0:
                     ib_vertices = list(reversed(ib_vertices))
-                ib_polygon_coordinates = [(v.X(), v.Y(), v.Z()) for v in ib_vertices]
+                ib_polygon_coordinates = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in ib_vertices]
                 ib_polygonxy = [(x[0], x[1]) for x in ib_polygon_coordinates]
                 ib_polygonsxy.append(ib_polygonxy)
                 zero_coordinates += ib_polygon_coordinates
@@ -3381,12 +3909,12 @@ class Wire():
 
         def perpendicular_distance(point, line_start, line_end):
             # Calculate the perpendicular distance from a point to a line segment
-            x0 = point.X()
-            y0 = point.Y()
-            x1 = line_start.X()
-            y1 = line_start.Y()
-            x2 = line_end.X()
-            y2 = line_end.Y()
+            x0 = Vertex.X(point)
+            y0 = Vertex.Y(point)
+            x1 = Vertex.X(line_start)
+            y1 = Vertex.Y(line_start)
+            x2 = Vertex.X(line_end)
+            y2 = Vertex.Y(line_end)
 
             numerator = abs((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1)
             denominator = Vertex.Distance(line_start, line_end)
@@ -3433,7 +3961,7 @@ class Wire():
             # Calculate the effective area for each point except the first and last
             def effective_area(p1, p2, p3):
                 # Triangle area formed by p1, p2, and p3
-                return 0.5 * abs(p1.X() * (p2.Y() - p3.Y()) + p2.X() * (p3.Y() - p1.Y()) + p3.X() * (p1.Y() - p2.Y()))
+                return 0.5 * abs(Vertex.X(p1) * (Vertex.Y(p2) - Vertex.Y(p3)) + Vertex.X(p2) * (Vertex.Y(p3) - Vertex.Y(p1)) + Vertex.X(p3) * (Vertex.Y(p1) - Vertex.Y(p2)))
 
             # Keep track of effective areas
             areas = [None]  # First point has no area
@@ -3911,9 +4439,9 @@ class Wire():
             else:
                 radius = radiusB
             angle = math.radians(360/sides)*i
-            x = math.sin(angle)*radius + origin.X()
-            y = math.cos(angle)*radius + origin.Y()
-            z = origin.Z()
+            x = math.sin(angle)*radius + Vertex.X(origin)
+            y = math.cos(angle)*radius + Vertex.Y(origin)
+            z = Vertex.Z(origin)
             xList.append(x)
             yList.append(y)
             baseV.append([x, y])
@@ -3921,29 +4449,29 @@ class Wire():
         if placement.lower() == "lowerleft":
             xmin = min(xList)
             ymin = min(yList)
-            xOffset = origin.X() - xmin
-            yOffset = origin.Y() - ymin
+            xOffset = Vertex.X(origin) - xmin
+            yOffset = Vertex.Y(origin) - ymin
         elif placement.lower() == "upperleft":
             xmin = min(xList)
             ymax = max(yList)
-            xOffset = origin.X() - xmin
-            yOffset = origin.Y() - ymax
+            xOffset = Vertex.X(origin) - xmin
+            yOffset = Vertex.Y(origin) - ymax
         elif placement.lower() == "lowerright":
             xmax = max(xList)
             ymin = min(yList)
-            xOffset = origin.X() - xmax
-            yOffset = origin.Y() - ymin
+            xOffset = Vertex.X(origin) - xmax
+            yOffset = Vertex.Y(origin) - ymin
         elif placement.lower() == "upperright":
             xmax = max(xList)
             ymax = max(yList)
-            xOffset = origin.X() - xmax
-            yOffset = origin.Y() - ymax
+            xOffset = Vertex.X(origin) - xmax
+            yOffset = Vertex.Y(origin) - ymax
         else:
             xOffset = 0
             yOffset = 0
         tranBase = []
         for coord in baseV:
-            tranBase.append(Vertex.ByCoordinates(coord[0]+xOffset, coord[1]+yOffset, origin.Z()))
+            tranBase.append(Vertex.ByCoordinates(coord[0]+xOffset, coord[1]+yOffset, Vertex.Z(origin)))
         
         baseWire = Wire.ByVertices(tranBase, True)
         baseWire = Wire.Reverse(baseWire)
@@ -4054,16 +4582,160 @@ class Wire():
             xOffset = -(max((widthA*0.5 + offsetA), (widthB*0.5 + offsetB)))
             yOffset = -length*0.5
 
-        vb1 = Vertex.ByCoordinates(origin.X()-widthA*0.5+offsetA+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb2 = Vertex.ByCoordinates(origin.X()+widthA*0.5+offsetA+xOffset,origin.Y()-length*0.5+yOffset,origin.Z())
-        vb3 = Vertex.ByCoordinates(origin.X()+widthB*0.5+offsetB+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
-        vb4 = Vertex.ByCoordinates(origin.X()-widthB*0.5++offsetB+xOffset,origin.Y()+length*0.5+yOffset,origin.Z())
+        vb1 = Vertex.ByCoordinates(Vertex.X(origin)-widthA*0.5+offsetA+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb2 = Vertex.ByCoordinates(Vertex.X(origin)+widthA*0.5+offsetA+xOffset,Vertex.Y(origin)-length*0.5+yOffset,Vertex.Z(origin))
+        vb3 = Vertex.ByCoordinates(Vertex.X(origin)+widthB*0.5+offsetB+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
+        vb4 = Vertex.ByCoordinates(Vertex.X(origin)-widthB*0.5++offsetB+xOffset,Vertex.Y(origin)+length*0.5+yOffset,Vertex.Z(origin))
 
         baseWire = Wire.ByVertices([vb1, vb2, vb3, vb4], True)
         if direction != [0, 0, 1]:
             baseWire = Topology.Orient(baseWire, origin=origin, dirA=[0, 0, 1], dirB=direction)
         return baseWire
 
+
+    @staticmethod
+    def TShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates a T-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the T-shape. The default is None which results in the L-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the T-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the T-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the T-shape. The default is 0.5.
+        b : float , optional
+            The vertical thickness of the horizontal arm of the T-shape. The default is 0.5.
+        direction : list , optional
+            The vector representing the up direction of the T-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the T-shape. 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.Wire
+            The created T-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Wire.LShape - 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.LShape - 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.LShape - 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.LShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Wire.LShape - 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.LShape - 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.LShape - 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.LShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Wire.LShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b >= (length - tolerance):
+            if not silent:
+                print("Wire.LShape - Error: The b input parameter must be less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Wire.LShape - 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.LShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Wire.LShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        
+        # Define the vertices of the T-shape (counterclockwise)
+        v1 = Vertex.ByCoordinates(width/2-a/2, 0)
+        v2 = Vertex.ByCoordinates(width/2+a/2, 0)
+        v3 = Vertex.ByCoordinates(width/2+a/2, length-b)
+        v4 = Vertex.ByCoordinates(width, length-b)
+        v5 = Vertex.ByCoordinates(width, length)
+        v6 = Vertex.ByCoordinates(0, length)
+        v7 = Vertex.ByCoordinates(0, length-b)
+        v8 = Vertex.ByCoordinates(width/2-a/2, length-b)  # Top of vertical arm
+
+        # Create the T-shaped wire
+        t_shape = Wire.ByVertices([v1, v2, v3, v4, v5, v6, v7, v8], close=True)
+        t_shape = Topology.Translate(t_shape, -width/2, -length/2, 0)
+        t_shape = Topology.Translate(t_shape, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+        reverse = False
+        if flipHorizontal == True:
+            xScale = -1
+            reverse = not reverse
+        else:
+            xScale = 1
+        if flipVertical == True:
+            yScale = -1
+            reverse = not reverse
+        else:
+            yScale = 1
+        if xScale == -1 or yScale == -1:
+            t_shape = Topology.Scale(t_shape, x=xScale, y=yScale, z=1)
+            if reverse == True:
+                t_shape = Wire.Reverse(t_shape)
+        if placement.lower() == "lowerleft":
+            t_shape = Topology.Translate(t_shape, width/2, length/2, 0)
+        elif placement.lower() == "upperright":
+            t_shape = Topology.Translate(t_shape, -width/2, -length/2, 0)
+        elif placement.lower() == "upperleft":
+            t_shape = Topology.Translate(t_shape, width/2, -length/2, 0)
+        elif placement.lower() == "lowerright":
+            t_shape = Topology.Translate(t_shape, -width/2, length/2, 0)
+        
+        if direction != [0, 0, 1]:
+            t_shape = Topology.Orient(t_shape, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        return t_shape
+
     @staticmethod
     def VertexDistance(wire, vertex, origin= None, mantissa: int = 6, tolerance: float = 0.0001):
         """