topologicpy 0.7.71__py3-none-any.whl → 0.7.73__py3-none-any.whl

topologicpy/BVH.py

@@ -41,6 +41,8 @@ class BVH:
 
         def intersects(self, other):
             # Check if this AABB intersects with another AABB
+            if other == None:
+                return False
             return np.all(self.min_point <= other.max_point) and np.all(self.max_point >= other.min_point)
 
         def contains(self, point):
@@ -200,13 +202,13 @@ class BVH:
         cluster = Cluster.ByTopologies(vertices)
         bb = Topology.BoundingBox(cluster)
         d = Topology.Dictionary(bb)
-        min_x = Dictionary.ValueAtKey(d, "minx")
-        min_y = Dictionary.ValueAtKey(d, "miny")
-        min_z = Dictionary.ValueAtKey(d, "minz")
-        max_x = Dictionary.ValueAtKey(d, "maxx")
-        max_y = Dictionary.ValueAtKey(d, "maxy")
-        max_z = Dictionary.ValueAtKey(d, "maxz")
-        query_aabb = BVH.AABB(min_point=(min_x, min_y, min_z), max_point=(max_x,max_y,max_z))
+        x_min = Dictionary.ValueAtKey(d, "xmin")
+        y_min = Dictionary.ValueAtKey(d, "ymin")
+        z_min = Dictionary.ValueAtKey(d, "zmin")
+        x_max = Dictionary.ValueAtKey(d, "zmax")
+        y_max = Dictionary.ValueAtKey(d, "ymax")
+        z_max = Dictionary.ValueAtKey(d, "zmax")
+        query_aabb = BVH.AABB(min_point=(x_min, y_min, z_min), max_point=(x_max, y_max, z_max))
         return query_aabb
     
     def Clashes(bvh, query):

topologicpy/CellComplex.py

@@ -103,6 +103,8 @@ class CellComplex():
             If set to True, any dictionaries in the cells are transferred to the CellComplex. Otherwise, they are not. The default is False.
         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
         -------
@@ -192,7 +194,7 @@ class CellComplex():
         return CellComplex.ByCells(cells, tolerance)
 
     @staticmethod
-    def ByFaces(faces: list, tolerance: float = 0.0001):
+    def ByFaces(faces: list, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a cellcomplex by merging the input faces.
 
@@ -202,6 +204,8 @@ class CellComplex():
             The input faces.
         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
         -------
@@ -213,38 +217,45 @@ class CellComplex():
         from topologicpy.Topology import Topology
 
         if not isinstance(faces, list):
-            print("CellComplex.ByFaces - Error: The input faces parameter is not a valid list. Returning None.")
+            if not silent:
+                print("CellComplex.ByFaces - Error: The input faces parameter is not a valid list. Returning None.")
             return None
         faces = [x for x in faces if Topology.IsInstance(x, "Face")]
         if len(faces) < 1:
-            print("CellComplex.ByFaces - Error: The input faces parameter does not contain any valid faces. Returning None.")
+            if not silent:
+                print("CellComplex.ByFaces - Error: The input faces parameter does not contain any valid faces. Returning None.")
             return None
         try:
             cellComplex = topologic.CellComplex.ByFaces(faces, tolerance, False) # Hook to Core
         except:
             cellComplex = None
         if not cellComplex:
-            print("CellComplex.ByFaces - Warning: The default method failed. Attempting a workaround.")
+            if not silent:
+                print("CellComplex.ByFaces - Warning: The default method failed. Attempting a workaround.")
             cellComplex = faces[0]
             for i in range(1,len(faces)):
                 newCellComplex = None
                 try:
                     newCellComplex = cellComplex.Merge(faces[i], False, tolerance)
                 except:
-                    print("CellComplex.ByFaces - Warning: Failed to merge face #"+str(i)+". Skipping.")
+                    if not silent:
+                        print("CellComplex.ByFaces - Warning: Failed to merge face #"+str(i)+". Skipping.")
                 if newCellComplex:
                     cellComplex = newCellComplex
             if not Topology.Type(cellComplex) == Topology.TypeID("CellComplex"):
-                print("CellComplex.ByFaces - Warning: The input faces do not form a cellcomplex")
+                if not silent:
+                    print("CellComplex.ByFaces - Warning: The input faces do not form a cellcomplex")
                 if Topology.Type(cellComplex) == Topology.TypeID("Cluster"):
                     returnCellComplexes = Cluster.CellComplexes(cellComplex)
                     if len(returnCellComplexes) > 0:
                         return returnCellComplexes[0]
                     else:
-                        print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
+                        if not silent:
+                            print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
                         return None
                 else:
-                    print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
+                    if not silent:
+                        print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
                     return None
         else:
             return cellComplex
@@ -892,33 +903,33 @@ class CellComplex():
                 x.append(Vertex.X(aVertex, mantissa=mantissa))
                 y.append(Vertex.Y(aVertex, mantissa=mantissa))
                 z.append(Vertex.Z(aVertex, mantissa=mantissa))
-            minX = min(x)
-            minY = min(y)
-            minZ = min(z)
+            x_min = min(x)
+            y_min = min(y)
+            z_min = min(z)
             maxX = max(x)
             maxY = max(y)
             maxZ = max(z)
-            return [minX, minY, minZ, maxX, maxY, maxZ]
+            return [x_min, y_min, z_min, maxX, maxY, maxZ]
         
         def slice(topology, uSides, vSides, wSides):
-            minX, minY, minZ, maxX, maxY, maxZ = bb(topology)
-            centroid = Vertex.ByCoordinates(minX+(maxX-minX)*0.5, minY+(maxY-minY)*0.5, minZ+(maxZ-minZ)*0.5)
-            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), minZ)
-            wFace = Face.Rectangle(origin=wOrigin, width=(maxX-minX)*1.1, length=(maxY-minY)*1.1)
+            x_min, y_min, z_min, maxX, maxY, maxZ = bb(topology)
+            centroid = Vertex.ByCoordinates(x_min+(maxX-x_min)*0.5, y_min+(maxY-y_min)*0.5, z_min+(maxZ-z_min)*0.5)
+            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), z_min)
+            wFace = Face.Rectangle(origin=wOrigin, width=(maxX-x_min)*1.1, length=(maxY-y_min)*1.1)
             wFaces = []
-            wOffset = (maxZ-minZ)/wSides
+            wOffset = (maxZ-z_min)/wSides
             for i in range(wSides-1):
                 wFaces.append(Topology.Translate(wFace, 0,0,wOffset*(i+1)))
-            uOrigin = Vertex.ByCoordinates(minX, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
-            uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-minZ)*1.1, length=(maxY-minY)*1.1, direction=[1,0,0])
+            uOrigin = Vertex.ByCoordinates(x_min, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
+            uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-z_min)*1.1, length=(maxY-y_min)*1.1, direction=[1,0,0])
             uFaces = []
-            uOffset = (maxX-minX)/uSides
+            uOffset = (maxX-x_min)/uSides
             for i in range(uSides-1):
                 uFaces.append(Topology.Translate(uFace, uOffset*(i+1),0,0))
-            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), minY, Vertex.Z(centroid, mantissa=mantissa))
-            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-minX)*1.1, length=(maxZ-minZ)*1.1, direction=[0,1,0])
+            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), y_min, Vertex.Z(centroid, mantissa=mantissa))
+            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-x_min)*1.1, length=(maxZ-z_min)*1.1, direction=[0,1,0])
             vFaces = []
-            vOffset = (maxY-minY)/vSides
+            vOffset = (maxY-y_min)/vSides
             for i in range(vSides-1):
                 vFaces.append(Topology.Translate(vFace, 0,vOffset*(i+1),0))
             all_faces = uFaces+vFaces+wFaces
@@ -995,6 +1006,64 @@ class CellComplex():
         shells = Topology.Shells(cellComplex)
         return shells
 
+    @staticmethod
+    def Torus(origin= None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates a torus.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the torus. The default is None which results in the torus being placed at (0, 0, 0).
+        majorRadius : float , optional
+            The major radius of the torus. The default is 0.5.
+        minorRadius : float , optional
+            The minor radius of the torus. The default is 0.1.
+        uSides : int , optional
+            The number of sides along the longitude of the torus. The default is 16.
+        vSides : int , optional
+            The number of sides along the latitude of the torus. The default is 8.
+        direction : list , optional
+            The vector representing the up direction of the torus. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the torus. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The created torus.
+
+        """
+        
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        
+        if not Topology.IsInstance(origin, "Vertex"):
+            origin = Vertex.ByCoordinates(0, 0, 0)
+        if not Topology.IsInstance(origin, "Vertex"):
+            print("Cell.Torus - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            return None
+        c = Wire.Circle(origin=Vertex.Origin(), radius=minorRadius, sides=vSides, fromAngle=0, toAngle=360, close=False, direction=[0, 1, 0], placement="center")
+        c = Face.ByWire(c)
+        c = Topology.Translate(c, abs(majorRadius-minorRadius), 0, 0)
+        torus = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0, 0, 1], angle=360, sides=uSides, tolerance=tolerance)
+        if Topology.Type(torus) == Topology.TypeID("Shell"):
+            faces = Topology.Faces(torus)
+            torus = CellComplex.ByFaces(faces)
+        if placement.lower() == "bottom":
+            torus = Topology.Translate(torus, 0, 0, minorRadius)
+        elif placement.lower() == "lowerleft":
+            torus = Topology.Translate(torus, majorRadius, majorRadius, minorRadius)
+
+        torus = Topology.Orient(torus, origin=Vertex.Origin(), dirA=[0, 0, 1], dirB=direction)
+        torus = Topology.Place(torus, originA=Vertex.Origin(), originB=origin)
+        return torus
+
     @staticmethod
     def Vertices(cellComplex) -> list:
         """

topologicpy/Cluster.py

@@ -166,7 +166,7 @@ class Cluster():
         from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
         import inspect
-
+        
         if len(args) == 0:
             if not silent:
                 print("Cluster.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")

topologicpy/Color.py

@@ -18,6 +18,44 @@ import plotly.colors
 import math
 
 class Color:
+
+    @staticmethod
+    def AnyToHex(color):
+        """
+        Converts a color to a hexadecimal color string.
+
+        Parameters
+        ----------
+        color : list or str
+            The input color parameter which can be any of RGB, CMYK, CSS Named Color, or Hex
+
+        Returns
+        -------
+        str
+            A hexadecimal color string in the format '#RRGGBB'.
+        """
+        return_hex = None
+        if isinstance(color, list):
+            if len(color) == 4: # Probably CMYK
+                if all(0 <= x <= 1 for x in color[:4]):
+                    return_hex = Color.CMYKToHex(color[:4])
+            elif len(color) == 3:
+                if all(0 <= x <= 255 for x in color[:3]):
+                    return_hex = Color.RGBToHex(color[:3])
+        elif isinstance(color, str): # Probably a CSSColor
+            if color.lower() in [x.lower() for x in Color.CSSNamedColors()]:
+                rgb = Color.ByCSSNamedColor(color.lower())
+                return_hex = Color.RGBToHex(rgb)
+            else: # Probably alread a HEX or other Plotly-compatible string
+                return_hex = color
+
+        if not isinstance(return_hex, str):
+            print("Color.AnyToHex - Error: Could not recognize the input parameter. Returning None.")
+            return None
+
+        return return_hex.upper()
+    
+    
     @staticmethod
     def ByCSSNamedColor(color, alpha: float = None):
         """
@@ -262,6 +300,34 @@ class Color:
             rgbList.append(alpha)
         return rgbList
     
+    @staticmethod
+    def CMYKToHex(cmyk):
+        """
+        Convert a CMYK color (list of 4 values) to its hexadecimal representation.
+        
+        Parameters
+        ----------
+        color : list
+            cmyk (list or tuple): CMYK color values as [C, M, Y, K], each in the range 0 to 1.
+
+        Returns
+        -------
+        str: The hexadecimal color string for Plotly (e.g., '#FFFFFF').
+        """
+        c, m, y, k = cmyk
+        
+        # Convert CMYK to RGB
+        r = 255 * (1 - c) * (1 - k)
+        g = 255 * (1 - m) * (1 - k)
+        b = 255 * (1 - y) * (1 - k)
+        
+        # Clamp RGB values to 0-255 range and convert to integers
+        r, g, b = int(round(r)), int(round(g)), int(round(b))
+        
+        # Convert RGB to hex format
+        hex_color = "#{:02x}{:02x}{:02x}".format(r, g, b)
+        return hex_color
+    
     @staticmethod
     def CSSNamedColor(color):
         """
@@ -355,7 +421,7 @@ class Color:
             "mediumorchid", "mediumpurple", "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise",
             "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin", "navajowhite", "navy", "oldlace",
             "olive", "olivedrab", "orange", "orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise",
-            "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple", "rebeccapurple",
+            "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple",
             "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", "seashell", "sienna",
             "silver", "skyblue", "slateblue", "slategray", "slategrey", "snow", "springgreen", "steelblue", "tan",
             "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen"

topologicpy/Dictionary.py

@@ -344,6 +344,97 @@ class Dictionary():
             values.append(pythonDictionary[key])
         return Dictionary.ByKeysValues(keys, values)
 
+    @staticmethod
+    def Filter(elements, dictionaries, searchType="any", key=None, value=None):
+        """
+        Filters the input list of dictionaries based on the input parameters.
+
+        Parameters
+        ----------
+        elements : list
+            The input list of elements to be filtered according to the input dictionaries.
+        dictionaries : list
+            The input list of dictionaries to be filtered.
+        searchType : str , optional
+            The type of search query to conduct in the topology's dictionary. This can be one of "any", "equal to", "contains", "starts with", "ends with", "not equal to", "does not contain". The default is "any".
+        key : str , optional
+            The dictionary key to search within. The default is None which means it will filter by topology type only.
+        value : str , optional
+            The value to search for at the specified key. The default is None which means it will filter by topology type only.
+
+        Returns
+        -------
+        dict
+            A dictionary of filtered and other elements. The dictionary has two keys:
+            - "filtered" The filtered dictionaries.
+            - "other" The other dictionaries that did not meet the filter criteria.
+            - "filteredIndices" The filtered indices of dictionaries.
+            - "otherIndices" The other indices of dictionaries that did not meet the filter criteria.
+
+        """
+
+        from topologicpy.Topology import Topology
+
+        def listToString(item):
+            returnString = ""
+            if isinstance(item, list):
+                if len(item) < 2:
+                    return str(item[0])
+                else:
+                    returnString = item[0]
+                    for i in range(1, len(item)):
+                        returnString = returnString+str(item[i])
+            return returnString
+        
+        filteredDictionaries = []
+        otherDictionaries = []
+        filteredElements = []
+        otherElements = []
+        filteredIndices = []
+        otherIndices = []
+        for i, aDictionary in enumerate(dictionaries):
+            if not Topology.IsInstance(aDictionary, "Dictionary"):
+                continue
+            if value == "" or key == "" or value == None or key == None:
+                filteredDictionaries.append(aDictionary)
+                filteredIndices.append(i)
+            else:
+                if isinstance(value, list):
+                    value.sort()
+                value = str(value)
+                value.replace("*",".+")
+                value = value.lower()
+                v = Dictionary.ValueAtKey(aDictionary, key)
+                if v == None:
+                    otherDictionaries.append(aDictionary)
+                    otherIndices.append(i)
+                    otherElements.append(elements[i])
+                else:
+                    v = str(v).lower()
+                    if searchType.lower() == "equal to":
+                        searchResult = (value == v)
+                    elif searchType.lower() == "contains":
+                        searchResult = (value in v)
+                    elif searchType.lower() == "starts with":
+                        searchResult = (value == v[0: len(value)])
+                    elif searchType.lower() == "ends with":
+                        searchResult = (value == v[len(v)-len(value):len(v)])
+                    elif searchType.lower() == "not equal to":
+                        searchResult = not (value == v)
+                    elif searchType.lower() == "does not contain":
+                        searchResult = not (value in v)
+                    else:
+                        searchResult = False
+                    if searchResult == True:
+                        filteredDictionaries.append(aDictionary)
+                        filteredIndices.append(i)
+                        filteredElements.append(elements[i])
+                    else:
+                        otherDictionaries.append(aDictionary)
+                        otherIndices.append(i)
+                        otherElements.append(elements[i])
+        return {"filteredDictionaries": filteredDictionaries, "otherDictionaries": otherDictionaries, "filteredIndices": filteredIndices, "otherIndices": otherIndices, "filteredElements": filteredElements, "otherElements": otherElements}
+
     @staticmethod
     def Keys(dictionary):
         """
@@ -579,7 +670,7 @@ class Dictionary():
             temp_value = attr.StringValue()
             topologies = None
             try:
-                topologies = Topology.ByJSONString(temp_value, progressBar=False)
+                topologies = Topology.ByJSONString(temp_value)
             except:
                 topologies = None
             if isinstance(topologies, list):
@@ -654,14 +745,21 @@ class Dictionary():
             if not silent == True:
                 print("Dictionary.ValueAtKey - Error: The input key parameter is not a valid str. Returning None.")
             return None
-        if isinstance(dictionary, dict):
-            attr = dictionary[key]
-        elif Topology.IsInstance(dictionary, "Dictionary"):
-            attr = dictionary.ValueAtKey(key)
-        else:
-            return None
-        return_value = Dictionary._ConvertAttribute(attr)
-        return return_value
+        if Topology.IsInstance(dictionary, "Dictionary"):
+            dic = Dictionary.PythonDictionary(dictionary)
+            return dic.get(key, None)
+        elif isinstance(dictionary, dict):
+            return dictionary.get(key, None)
+        return None
+        
+        # if isinstance(dictionary, dict):
+        #     attr = dictionary[key]
+        # elif Topology.IsInstance(dictionary, "Dictionary"):
+        #     attr = dictionary.ValueAtKey(key)
+        # else:
+        #     return None
+        # return_value = Dictionary._ConvertAttribute(attr)
+        # return return_value
         
     @staticmethod
     def Values(dictionary):
@@ -693,7 +791,7 @@ class Dictionary():
         for key in keys:
             try:
                 if isinstance(dictionary, dict):
-                    attr = dictionary[key]
+                    attr = dictionary.get(key, None)
                 elif Topology.IsInstance(dictionary, "Dictionary"):
                     attr = Dictionary.ValueAtKey(dictionary,key)
                 else:

topologicpy/Edge.py

@@ -1143,6 +1143,8 @@ class Edge():
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
 
+
+
         def calculate_normal(start_vertex, end_vertex):
             start_vertex = np.array([float(x) for x in start_vertex])
             end_vertex = np.array([float(x) for x in end_vertex])
@@ -1150,8 +1152,11 @@ class Edge():
             # Calculate the direction vector of the edge
             direction_vector = end_vertex - start_vertex
             
-            # Handle the horizontal edge case (no Z component)
-            if np.isclose(direction_vector[2], 0):
+            # Check if the edge is vertical (only Z component)
+            if np.isclose(direction_vector[0], 0) and np.isclose(direction_vector[1], 0):
+                # Choose an arbitrary perpendicular vector in the X-Y plane, e.g., [1, 0, 0]
+                normal_vector = np.array([1.0, 0.0, 0.0])
+            elif np.isclose(direction_vector[2], 0):
                 # The edge lies in the X-Y plane; compute a perpendicular in the X-Y plane
                 normal_vector = np.array([-direction_vector[1], direction_vector[0], 0.0])
             else:
@@ -1162,7 +1167,7 @@ class Edge():
             # Check if the normal vector is effectively zero before normalization
             if np.isclose(norm(normal_vector), 0):
                 return normal_vector
-            
+    
             # Normalize the normal vector
             normal_vector /= norm(normal_vector)  
             return normal_vector
@@ -1192,7 +1197,6 @@ class Edge():
 
         # Calculate the normal line
         normal_line_start, normal_line_end = calculate_normal_line(start_vertex, end_vertex)
-
         # Create the normal edge in Topologic
         sv = Vertex.ByCoordinates(list(normal_line_start))
         ev = Vertex.ByCoordinates(list(normal_line_end))

topologicpy/Face.py

@@ -2566,7 +2566,7 @@ class Face():
                 internal_face_number = len(face_internal_boundaries)
                 for i in range(internal_face_number):
                     face_internal_boundary = face_internal_boundaries[i]
-                    internal_vertices = Wire.Vertices(face_internal_boundary)
+                    internal_vertices = Topology.Vertices(face_internal_boundary)
                     internal_vertex_number = len(internal_vertices)
                     for j in range(internal_vertex_number):
                         gmsh.model.geo.addPoint(Vertex.X(internal_vertices[j]), Vertex.Y(internal_vertices[j], mantissa=mantissa), Vertex.Z(internal_vertices[j], mantissa=mantissa), meshSize, current_vertex_number+j+1)