topologicpy 0.8.0__py3-none-any.whl → 0.8.3__py3-none-any.whl

topologicpy/Cluster.py

@@ -1247,6 +1247,73 @@ class Cluster():
             return resultingTopologies[0]
         return cluster
 
+    @staticmethod
+    def Tripod(size: float = 1.0,
+               radius: float = 0.03,
+               sides: int = 4,
+               faceColorKey="faceColor",
+               xColor = "red",
+               yColor = "green",
+               zColor = "blue",
+               matrix=None):
+        """
+        Creates a color-coded Axes tripod for X, Y, and Z axes. X-Axis is red, Y-Axis is "green", and Z-Axis= "blue"
+
+        Parameters
+        ----------
+        size : float , optional
+            The desired size of the tripod. The default is 1.0.
+        radius : float , optional
+            The desired radiues of the tripod. The default is 0.03
+        sides : int , optional
+            The desired number of sides of the tripod. The default is 4.
+        faceColorKey : str , optional
+            The dictionary key under which to store the colors of the axes.
+        xColor : str , optional
+            The color to use for the X axis. The default is "red".
+        yColor : str , optional
+            The color to use for the Y axis. The default is "green".
+        zColor : str , optional
+            The color to use for the Z axis. The default is "blue".
+        matrix : list , optional
+            The desired 4X4 transformation matrix to use for transforming the tripod. The default is None which means the tripod will be placed at the origin and will be axis-aligned. 
+
+        Returns
+        -------
+        topologic_core.Cluster
+            The created tripod
+
+        """
+
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        cyl = Cell.Cylinder(radius=radius, height=size - size*0.3, uSides=sides, placement="bottom")
+        cone = Cell.Cone(baseRadius=radius*2.25, height=size*0.3, placement="bottom", uSides=sides)
+        cone = Topology.Translate(cone, 0, 0, size - size*0.3)
+        z_arrow = Topology.Union(cyl, cone)
+        x_arrow = Topology.Rotate(z_arrow, axis=[0,1,0], angle=90)
+        y_arrow = Topology.Rotate(z_arrow, axis=[1,0,0], angle=-90)
+
+        x_faces = Topology.Faces(x_arrow)
+        for x_face in x_faces:
+            d = Dictionary.ByKeyValue(faceColorKey, xColor)
+            x_face = Topology.SetDictionary(x_face, d)
+        y_faces = Topology.Faces(y_arrow)
+        for y_face in y_faces:
+            d = Dictionary.ByKeyValue(faceColorKey, yColor)
+            y_face = Topology.SetDictionary(y_face, d)
+        z_faces = Topology.Faces(z_arrow)
+        for z_face in z_faces:
+            d = Dictionary.ByKeyValue(faceColorKey, zColor)
+            z_face = Topology.SetDictionary(z_face, d)
+
+        cluster = Cluster.ByTopologies(x_arrow, y_arrow, z_arrow)
+        if not matrix == None:
+            cluster = Topology.Transform(cluster, matrix=matrix)
+        return cluster
+
     @staticmethod
     def Vertices(cluster) -> list:
         """

topologicpy/Edge.py

@@ -17,6 +17,63 @@
 import topologic_core as topologic
 
 class Edge():
+
+    @staticmethod
+    def Align2D(edgeA, edgeB):
+        """
+        Compute the 4x4 transformation matrix to fully align edgeA to edgeB.
+
+        Parameters:
+            edge1 (Edge): The source 2D edge to transform.
+            edge2 (Edge): The target 2D edge.
+
+        Returns:
+            list: A 4x4 transformation matrix.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Matrix import Matrix
+        from topologicpy.Vector import Vector
+
+        centroid1 = Topology.Centroid(edgeA)
+        centroid2 = Topology.Centroid(edgeB)
+        # Extract coordinates
+        x1, y1, z1 = Vertex.Coordinates(centroid1)
+        x2, y2, z2 = Vertex.Coordinates(centroid2)
+
+        # Translation to move edge1 to the origin
+        move_to_origin = Matrix.ByTranslation(-x1, -y1, -z1)
+        
+        # Translation to move edge1 from the origin to the start of edge2
+        move_to_target = Matrix.ByTranslation(x2, y2, z2)
+
+        # Lengths of the edges
+        length1 = Edge.Length(edgeA)
+        length2 = Edge.Length(edgeB)
+
+        if length1 == 0 or length2 == 0:
+            raise ValueError("Edges must have non-zero length.")
+
+        # Calculate scaling factor
+        scale_factor = length2 / length1
+        # Scaling matrix
+        scaling_matrix = Matrix.ByScaling(scale_factor, scale_factor, 1.0)
+
+        # Calculate angles of the edges relative to the X-axis
+        angle1 = Vector.CompassAngle(Edge.Direction(edgeA), [1,0,0])
+        angle2 = Vector.CompassAngle(Edge.Direction(edgeB), [1,0,0])
+        # Rotation angle
+        rotation_angle = angle2 - angle1
+        # Rotation matrix (about Z-axis for 2D alignment)
+        rotation_matrix = Matrix.ByRotation(0, 0, rotation_angle, order="xyz")
+
+        # Combine transformations: Move to origin -> Scale -> Rotate -> Move to target
+        transformation_matrix = Matrix.Multiply(scaling_matrix, move_to_origin)
+        transformation_matrix = Matrix.Multiply(rotation_matrix, transformation_matrix)
+        transformation_matrix = Matrix.Multiply(move_to_target, transformation_matrix)
+        return transformation_matrix
+
     @staticmethod
     def Angle(edgeA, edgeB, mantissa: int = 6, bracket: bool = False) -> float:
         """
@@ -268,6 +325,50 @@ class Edge():
             edge = None
         return edge
     
+    @staticmethod
+    def ByOriginDirectionLength(origin = None, direction=[0,0,1], length: float = 1.0, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a straight edge from the input parameters.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex
+            The origin (start vertex) of the edge.
+        direction : list , optional
+            The desired direction vector of the edge. The default is [0,0,1] (pointing up in the Z direction)
+        length: float , optional
+            The desired length of edge. The default is 1.0.
+        tolerance : float , optional
+            The desired tolerance to decide if an edge can be created. 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.Edge
+            The created edge.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+
+        if origin == None:
+            origin = Vertex.Origin()
+        
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Edge.ByVertexDirectionLength - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if length < tolerance:
+            if not silent:
+                print("Edge.ByVertexDirectionLength - Error: The input edge parameter must not be less than the input tolerance parameter. Returning None.")
+            return None
+
+        endVertex = Topology.TranslateByDirectionDistance(origin, direction=direction[:3], distance=length)
+        edge = Edge.ByVertices(origin, endVertex, tolerance=tolerance)
+        return edge
+
     @staticmethod
     def ByVertices(*args, tolerance: float = 0.0001, silent: bool = False):
         """

topologicpy/Face.py

@@ -1124,6 +1124,162 @@ class Face():
         dirA = Face.Normal(face, outputType="xyz", mantissa=mantissa)
         return Vector.CompassAngle(vectorA=dirA, vectorB=north, mantissa=mantissa, tolerance=tolerance)
 
+    @staticmethod
+    def CrossShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            c=None,
+            d=None,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates a Cross-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the T-shape. The default is None which results in the Cross-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the Cross-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the Cross-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the Cross-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the horizontal arm of the Cross-shape. The default is 0.25.
+        c : float , optional
+            The distance of the vertical symmetry axis measured from the left side of the Cross-shape. The default is None which results in the Cross-shape being symmetrical on the Y-axis.
+        d : float , optional
+            The distance of the horizontal symmetry axis measured from the bottom side of the Cross-shape. The default is None which results in the Cross-shape being symmetrical on the X-axis.
+        direction : list , optional
+            The vector representing the up direction of the Cross-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the Cross-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.Face
+            The created Cross-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.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.")
+            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.")
+            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.")
+            return None
+        if c == None:
+            c = width/2
+        if d == None:
+            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.")
+            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.")
+        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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            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.")
+            return None
+        cross_shape_wire = Wire.CrossShape(origin=origin,
+                                   width=width,
+                                   length=length,
+                                   a=a,
+                                   b=b,
+                                   c=c,
+                                   d=d,
+                                   flipHorizontal=flipHorizontal,
+                                   flipVertical=flipVertical,
+                                   direction=direction,
+                                   placement=placement,
+                                   tolerance=tolerance,
+                                   silent=silent)
+        return Face.ByWire(cross_shape_wire, tolerance=tolerance, silent=silent)
+
     @staticmethod
     def CShape(origin=None,
             width=1,
@@ -3545,8 +3701,8 @@ class Face():
     def TShape(origin=None,
             width=1,
             length=1,
-            a=0.5,
-            b=0.5,
+            a=0.25,
+            b=0.25,
             flipHorizontal = False,
             flipVertical = False,
             direction=[0,0,1],
@@ -3565,9 +3721,9 @@ class Face():
         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.
+            The hortizontal thickness of the vertical arm of the T-shape. The default is 0.25.
         b : float , optional
-            The vertical thickness of the horizontal arm of the T-shape. The default is 0.5.
+            The vertical thickness of the horizontal arm of the T-shape. The default is 0.25.
         direction : list , optional
             The vector representing the up direction of the T-shape. The default is [0, 0, 1].
         placement : str , optional

topologicpy/Helper.py

@@ -98,29 +98,29 @@ class Helper:
     @staticmethod
     def ClusterByKeys(elements, dictionaries, *keys, silent=False):
         """
-            Clusters the input list of elements and dictionaries based on the input key or keys.
-
-            Parameters
-            ----------
-            elements : list
-                The input list of elements to be clustered.
-            dictionaries : list[Topology.Dictionary]
-                The input list of dictionaries to be consulted for clustering. This is assumed to be in the same order as the list of elements.
-            keys : str or list or comma-separated str input parameters
-                The key or keys in the topology's dictionary to use for clustering.
-            silent : bool , optional
-                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
-
-
-            Returns
-            -------
-            dict
-                A dictionary containing the elements and the dictionaries, but clustered. The dictionary has two keys:
-                "elements": list
-                    A nested list of elements where each item is a list of elements with the same key values.
-                "dictionaries": list
-                    A nested list of dictionaries where each item is a list of dictionaries with the same key values.
-            """
+        Clusters the input list of elements and dictionaries based on the input key or keys.
+
+        Parameters
+        ----------
+        elements : list
+            The input list of elements to be clustered.
+        dictionaries : list[Topology.Dictionary]
+            The input list of dictionaries to be consulted for clustering. This is assumed to be in the same order as the list of elements.
+        keys : str or list or comma-separated str input parameters
+            The key or keys in the topology's dictionary to use for clustering.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+
+        Returns
+        -------
+        dict
+            A dictionary containing the elements and the dictionaries, but clustered. The dictionary has two keys:
+            "elements": list
+                A nested list of elements where each item is a list of elements with the same key values.
+            "dictionaries": list
+                A nested list of dictionaries where each item is a list of dictionaries with the same key values.
+        """
         
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
@@ -275,6 +275,41 @@ class Helper:
             iterated_list.append(y)
         return iterated_list
     
+    @staticmethod
+    def MakeUnique(listA):
+        """
+        Forces the strings in the input list to be unique if they have duplicates.
+
+        Parameters
+        ----------
+        listA : list
+            The input list of strings.
+
+        Returns
+        -------
+        list
+            The input list, but with each item ensured to be unique if they have duplicates.
+
+        """
+        # Create a dictionary to store counts of each string
+        counts = {}
+        # Create a list to store modified strings
+        unique_strings = []
+        
+        for string in listA:
+            # If the string already exists in the counts dictionary
+            if string in counts:
+                # Increment the count
+                counts[string] += 1
+                # Append the modified string with underscore and count
+                unique_strings.append(f"{string}_{counts[string]}")
+            else:
+                # If it's the first occurrence of the string, add it to the counts dictionary
+                counts[string] = 0
+                unique_strings.append(string)
+        
+        return unique_strings
+    
     @staticmethod
     def MergeByThreshold(listA, threshold=0.0001):
         """
@@ -312,39 +347,76 @@ class Helper:
         return merged_list
     
     @staticmethod
-    def MakeUnique(listA):
+    def MaximumIndices(listA, silent: bool = False):
         """
-        Forces the strings in the input list to be unique if they have duplicates.
+        Returns a list of indices of the maximum value in the input list.
+        For example, if the input list is [7,3,4,7,5,7] then the returned list is [0,3,5] to indicate the indices of the maximum value (7).
 
         Parameters
         ----------
         listA : list
-            The input list of strings.
+            The input list.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
         list
-            The input list, but with each item ensured to be unique if they have duplicates.
+            The resulting list.
 
         """
-        # Create a dictionary to store counts of each string
-        counts = {}
-        # Create a list to store modified strings
-        unique_strings = []
+        if not isinstance(listA, list):
+            if not silent:
+                print("Helper.MaximumIndices - Error: The input listA parameter is not a valid list. Returning None.")
+            return None
+        if len(listA) == 0:
+            return []
+        if len(listA) == 1:
+            return [0]
+    
+        # Find the maximum value in the list
+        max_value = min(listA)
         
-        for string in listA:
-            # If the string already exists in the counts dictionary
-            if string in counts:
-                # Increment the count
-                counts[string] += 1
-                # Append the modified string with underscore and count
-                unique_strings.append(f"{string}_{counts[string]}")
-            else:
-                # If it's the first occurrence of the string, add it to the counts dictionary
-                counts[string] = 0
-                unique_strings.append(string)
+        # Find all indices where this minimum value occurs
+        indices = [i for i, value in enumerate(listA) if value == max_value]
         
-        return unique_strings
+        return indices
+    
+    @staticmethod
+    def MinimumIndices(listA, silent: bool = False):
+        """
+        Returns a list of indices of the minimum value in the input list.
+        For example, if the input list is [1,3,4,1,5,1] then the returned list is [0,3,5] to indicate the indices of the minimum value (1).
+
+        Parameters
+        ----------
+        listA : list
+            The input list.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        list
+            The resulting list.
+
+        """
+        if not isinstance(listA, list):
+            if not silent:
+                print("Helper.MinimumIndices - Error: The input listA parameter is not a valid list. Returning None.")
+            return None
+        if len(listA) == 0:
+            return []
+        if len(listA) == 1:
+            return [0]
+    
+        # Find the minimum value in the list
+        min_value = min(listA)
+        
+        # Find all indices where this minimum value occurs
+        indices = [i for i, value in enumerate(listA) if value == min_value]
+        
+        return indices
     
     @staticmethod
     def Normalize(listA, mantissa: int = 6):
@@ -356,7 +428,7 @@ class Helper:
         listA : list
             The input nested list.
         mantissa : int , optional
-            The desired mantissa value. The default is 6.
+            The desired length of the mantissa. The default is 6.
 
         Returns
         -------
@@ -415,6 +487,48 @@ class Helper:
         # If the target is not found, return the position where it would be inserted
         return left
     
+    @staticmethod 
+    def RemoveEven(listA):
+        """
+        Removes the even indexed members of the input list.
+
+        Parameters
+        ----------
+        listA : list
+            The input list.
+
+        Returns
+        -------
+        list
+            The resulting list.
+
+        """
+        return_list = []
+        for i in range(1, len(listA), 2):
+            return_list.append(listA[i])
+        return return_list
+    
+    @staticmethod 
+    def RemoveOdd(listA):
+        """
+        Removes the odd indexed members of the input list.
+
+        Parameters
+        ----------
+        listA : list
+            The input list.
+
+        Returns
+        -------
+        list
+            The resulting list.
+
+        """
+        return_list = []
+        for i in range(0, len(listA), 2):
+            return_list.append(listA[i])
+        return return_list
+    
     @staticmethod
     def Repeat(listA):
         """