topologicpy 0.4.55__py3-none-any.whl → 0.4.57__py3-none-any.whl

topologicpy/Graph.py

@@ -4183,6 +4183,12 @@ class Graph:
         for edge in Topology.Edges(temp_path):
             new_edges.append(g_edges[Edge.Index(edge, g_edges)])
         longest_path = Topology.SelfMerge(Cluster.ByTopologies(new_edges), tolerance=tolerance)
+        sv = Topology.Vertices(longest_path)[0]
+        if Vertex.Distance(sv, vertexB) < tolerance: # Wire is reversed. Re-reverse it
+            if isinstance(longest_path, topologic.Edges):
+                longest_path = Edge.Reverse(longest_path)
+            if isinstance(longest_path, topologic.Wire):
+                longest_path = Wire.Reverse(longest_path)
         if not costKey == None:
             lengths.sort()
             d = Dictionary.ByKeysValues([costKey], [cost])
@@ -4874,7 +4880,7 @@ class Graph:
         return graph
 
     @staticmethod
-    def ShortestPath(graph, vertexA, vertexB, vertexKey="", edgeKey="Length"):
+    def ShortestPath(graph, vertexA, vertexB, vertexKey="", edgeKey="Length", tolerance=0.0001):
         """
         Returns the shortest path that connects the input vertices.
 
@@ -4890,13 +4896,19 @@ class Graph:
             The vertex key to minimise. If set the vertices dictionaries will be searched for this key and the associated value will be used to compute the shortest path that minimized the total value. The value must be numeric. The default is None.
         edgeKey : string , optional
             The edge key to minimise. If set the edges dictionaries will be searched for this key and the associated value will be used to compute the shortest path that minimized the total value. The value of the key must be numeric. If set to "length" (case insensitive), the shortest path by length is computed. The default is "length".
-
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
         Returns
         -------
         topologic.Wire
             The shortest path between the input vertices.
 
         """
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
         if not isinstance(graph, topologic.Graph):
             print("Graph.ShortestPath - Error: The input graph is not a valid graph. Returning None.")
             return None
@@ -4910,7 +4922,16 @@ class Graph:
             if edgeKey.lower() == "length":
                 edgeKey = "Length"
         try:
-            return graph.ShortestPath(vertexA, vertexB, vertexKey, edgeKey)
+            gsv = Graph.NearestVertex(graph, vertexA, tolerance)
+            gev = Graph.NearestVertex(graph, vertexB, tolerance)
+            shortest_path = graph.ShortestPath(gsv, gev, vertexKey, edgeKey)
+            sv = Topology.Vertices(shortest_path)[0]
+            if Vertex.Distance(sv, gev) < tolerance: # Path is reversed. Correct it.
+                if isinstance(shortest_path, topologic.Edges):
+                    shortest_path = Edge.Reverse(shortest_path)
+                if isinstance(shortest_path, topologic.Wire):
+                    shortest_path = Wire.Reverse(shortest_path)
+                return shortest_path
         except:
             return None
 
@@ -4936,62 +4957,49 @@ class Graph:
             The search time limit in seconds. The default is 10 seconds
         pathLimit: int , optional
             The number of found paths limit. The default is 10 paths.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
-        topologic.Wire
+        list
             The list of shortest paths between the input vertices.
 
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
-        def nearestVertex(g, v, tolerance):
-            vertices = Graph.Vertices(g)
-            for aVertex in vertices:
-                d = Vertex.Distance(v, aVertex)
-                if d < tolerance:
-                    return aVertex
-            return None
         
-        def isUnique(paths, wire):
+        def isUnique(paths, path):
+            if path == None:
+                return False
             if len(paths) < 1:
                 return True
             for aPath in paths:
                 copyPath = topologic.Topology.DeepCopy(aPath)
-                dif = copyPath.Difference(wire, False)
+                dif = copyPath.Difference(path, False)
                 if dif == None:
                     return False
             return True
         
         if not isinstance(graph, topologic.Graph):
-            print("Graph.ShortestPaths - Error: The input graph is not a valid graph. Returning None.")
+            print("Graph.ShortestPaths - Error: The input graph parameter is not a valid graph. Returning None.")
             return None
         if not isinstance(vertexA, topologic.Vertex):
-            print("Graph.ShortestPaths - Error: The input vertexA is not a valid vertex. Returning None.")
+            print("Graph.ShortestPaths - Error: The input vertexA parameter is not a valid vertex. Returning None.")
             return None
         if not isinstance(vertexB, topologic.Vertex):
-            print("Graph.ShortestPaths - Error: The input vertexB is not a valid vertex. Returning None.")
+            print("Graph.ShortestPaths - Error: The input vertexB parameter is not a valid vertex. Returning None.")
             return None
         shortestPaths = []
         end = time.time() + timeLimit
         while time.time() < end and len(shortestPaths) < pathLimit:
-            gsv = nearestVertex(graph, vertexA, tolerance)
-            gev = nearestVertex(graph, vertexB, tolerance)
             if (graph != None):
                 if edgeKey:
                     if edgeKey.lower() == "length":
                         edgeKey = "Length"
-                wire = graph.ShortestPath(gsv,gev,vertexKey,edgeKey) # Find the first shortest path
-                wireVertices = []
-                flag = False
-                try:
-                    wireVertices = Wire.Vertices(wire)
-                    flag = True
-                except:
-                    flag = False
-                if (flag):
-                    if isUnique(shortestPaths, wire):
-                        shortestPaths.append(wire)
+                shortest_path = Graph.ShortestPath(graph, vertexA, vertexB, vertexKey=vertexKey, edgeKey=edgeKey, tolerance=tolerance) # Find the first shortest path
+                if isUnique(shortestPaths, shortest_path):
+                    shortestPaths.append(shortest_path)
                 vertices = Graph.Vertices(graph)
                 random.shuffle(vertices)
                 edges = Graph.Edges(graph)
@@ -5399,11 +5407,6 @@ class Graph:
                             e = Topology.Boolean(e, boundaryFace, operation="intersect", tolerance=tolerance)
                             if isinstance(e, topologic.Edge):
                                 edges = addEdge(e, edges, viewpointsA, viewpointsB, 0.0001)
-                            elif isinstance(e, topologic.Cluster):
-                                tempEdges = Cluster.Edges(e)
-                                if tempEdges:
-                                    for tempEdge in tempEdges:
-                                        edges = addEdge(tempEdge, edges, viewpointsA, viewpointsB, 0.0001)
 
         except:
             for i in range(len(viewpointsA)):

topologicpy/Helper.py

@@ -5,7 +5,7 @@ import math
 
 class Helper:
     @staticmethod
-    def Flatten(l):
+    def Flatten(listA):
         """
         Flattens the input nested list.
 
@@ -21,22 +21,22 @@ class Helper:
 
         """
 
-        if not isinstance(l, list):
-            return [l]
+        if not isinstance(listA, list):
+            return [listA]
         flat_list = []
-        for item in l:
+        for item in listA:
             flat_list = flat_list + Helper.Flatten(item)
         return flat_list
 
     @staticmethod
-    def Iterate(l):
+    def Iterate(listA):
         """
         Iterates the input nested list so that each sublist has the same number of members. To fill extra members, the shorter lists are iterated from their first member.
         For example Iterate([[1,2,3],['m','n','o','p'],['a','b','c','d','e']]) yields [[1, 2, 3, 1, 2], ['m', 'n', 'o', 'p', 'm'], ['a', 'b', 'c', 'd', 'e']]
 
         Parameters
         ----------
-        l : list
+        listA : list
             The input nested list.
 
         Returns
@@ -56,13 +56,13 @@ class Helper:
                 base = base[1:]+[base[0]]  # rotate
             return base
 
-        maxLength = len(l[0])
+        maxLength = len(listA[0])
         iterated_list = []
-        for aSubList in l:
+        for aSubList in listA:
             newLength = len(aSubList)
             if newLength > maxLength:
                 maxLength = newLength
-        for anItem in l:
+        for anItem in listA:
             for i in range(len(anItem), maxLength):
                 anItem.append(None)
             y=[]
@@ -107,13 +107,13 @@ class Helper:
         return {'clusters': clusters, 'centroids': centroids}
     
     @staticmethod
-    def MergeByThreshold(l, threshold=0.0001):
+    def MergeByThreshold(listA, threshold=0.0001):
         """
         Merges the numbers in the input list so that numbers within the input threshold are averaged into one number.
 
         Parameters
         ----------
-        l : list
+        listA : list
             The input nested list.
         threshold : float , optional
             The desired merge threshold value. The default is 0.0001.
@@ -125,31 +125,31 @@ class Helper:
 
         """
         # Sort the list in ascending order
-        l.sort()
+        listA.sort()
         merged_list = []
 
         # Initialize the first element in the merged list
-        merged_list.append(l[0])
+        merged_list.append(listA[0])
 
         # Merge numbers within the threshold
-        for i in range(1, len(l)):
-            if l[i] - merged_list[-1] <= threshold:
+        for i in range(1, len(listA)):
+            if listA[i] - merged_list[-1] <= threshold:
                 # Merge the current number with the last element in the merged list
-                merged_list[-1] = (merged_list[-1] + l[i]) / 2
+                merged_list[-1] = (merged_list[-1] + listA[i]) / 2
             else:
                 # If the current number is beyond the threshold, add it as a new element
-                merged_list.append(l[i])
+                merged_list.append(listA[i])
 
         return merged_list
 
     @staticmethod
-    def Normalize(l, mantissa: int = 6):
+    def Normalize(listA, mantissa: int = 6):
         """
         Normalizes the input list so that it is in the range 0 to 1
 
         Parameters
         ----------
-        l : list
+        listA : list
             The input nested list.
         mantissa : int , optional
             The desired mantissa value. The default is 4.
@@ -160,12 +160,12 @@ class Helper:
             The normalized list.
 
         """
-        if l == None:
+        if not isinstance(listA, list):
             print("Helper.Normalize - Error: The input list is not valid. Returning None.")
             return None
         
         # Make sure the list is numeric
-        l = [x for x in l if type(x) == int or type(x) == float]
+        l = [x for x in listA if type(x) == int or type(x) == float]
         if len(l) < 1:
             print("Helper.Normalize - Error: The input list does not contain numeric values. Returning None.")
             return None
@@ -178,14 +178,14 @@ class Helper:
         return normalized_list
 
     @staticmethod
-    def Repeat(l):
+    def Repeat(listA):
         """
         Repeats the input nested list so that each sublist has the same number of members. To fill extra members, the last item in the shorter lists are repeated and appended.
         For example Iterate([[1,2,3],['m','n','o','p'],['a','b','c','d','e']]) yields [[1, 2, 3, 3, 3], ['m', 'n', 'o', 'p', 'p'], ['a', 'b', 'c', 'd', 'e']]
 
         Parameters
         ----------
-        l : list
+        listA : list
             The input nested list.
 
         Returns
@@ -194,9 +194,9 @@ class Helper:
             The repeated list.
 
         """
-        if not isinstance(l, list):
+        if not isinstance(listA, list):
             return None
-        repeated_list = [x for x in l if isinstance(x, list)]
+        repeated_list = [x for x in listA if isinstance(x, list)]
         if len(repeated_list) < 1:
             return None
         maxLength = len(repeated_list[0])
@@ -214,16 +214,27 @@ class Helper:
         return repeated_list
 
     @staticmethod
-    def Sort(lA, lB):
+    def Sort(listA, *otherLists, reverseFlags=None):
         """
-        Sorts the first input list according to the values in the second input list.
+        Sorts the first input list according to the values in the subsequent input lists in order. For example,
+        your first list can be a list of topologies and the next set of lists can be their volume, surface area, and z level.
+        The list of topologies will then be sorted first by volume, then by surface, and lastly by z level. You can choose
+        to reverse the order of sorting by including a list of TRUE/FALSE values in the reverseFlags input parameter.
+        For example, if you wish to sort the volume in reverse order (from large to small), but sort the other parameters
+        normally, you would include the following list for reverseFlag: [True, False, False].
 
         Parameters
         ----------
-        lA : list
+        listA : list
             The first input list to be sorts
-        lB : list
-            The second input list to use for sorting the first input list.
+        *otherLists : any number of lists to use for sorting listA, optional.
+            Any number of lists that are used to sort the listA input parameter. The order of these input
+            parameters determines the order of sorting (from left to right). If no lists are included, the input list will be sorted as is.
+        reverseFlags : list, optional.
+            The list of booleans (TRUE/FALSE) to indicated if sorting based on a particular list should be conducted in reverse order.
+            The length of the reverseFlags list should match the number of the lists in the input otherLists parameter. If set to None,
+            a default list of FALSE values is created to match the number of the lists in the input otherLists parameter. The default
+            is None.
 
         Returns
         -------
@@ -231,17 +242,45 @@ class Helper:
             The sorted list.
 
         """
-        lA.sort(key=dict(zip(lA, lB)).get)
-        return lA
+       
+        # If reverseFlags is not provided, assume all lists should be sorted in ascending order
+        if reverseFlags is None:
+            reverseFlags = [False] * len(otherLists)
+        if not isinstance(otherLists, tuple):
+            print("Helper.Sort - Error: No other lists to use for sorting have been provided. Returning None.")
+            return None
+        if len(otherLists) < 1:
+            print("Helper.Sort - Error: The otherLists input parameter does not contain any valid lists. Returning None.")
+            return None
+        if not len(reverseFlags) == len(otherLists):
+            print("Helper.Sort - Error: The length of the reverseFlags input parameter is not equal to the number of input lists. Returning None.")
+            return None
+        # Convert other_lists to numeric and reverse if needed.
+        sorting_lists = []
+        for i, a_list in enumerate(otherLists):
+            temp_list = []
+            temp_set = list(set(a_list))
+            temp_set = sorted(temp_set)
+            if reverseFlags[i] == True:
+                temp_set.reverse()
+            for item in a_list:
+                temp_list.append(temp_set.index(item))
+            sorting_lists.append(temp_list)
+    
+        combined_lists = list(zip(listA, *sorting_lists))
+        # Sort the combined list based on all the elements and reverse the lists as needed
+        combined_lists.sort(key=lambda x: tuple((-val) if reverse else val for val, reverse in zip(x[1:], reverseFlags)))
+        sorted_listA = [item[0] for item in combined_lists]
+        return sorted_listA
 
     @staticmethod
-    def Transpose(l):
+    def Transpose(listA):
         """
-        Transposes (swaps rows and columns) the input list.
+        Transposes the input list (swaps rows and columns).
 
         Parameters
         ----------
-        l : list
+        listA : list
             The input list.
 
         Returns
@@ -250,26 +289,26 @@ class Helper:
             The transposed list.
 
         """
-        if not isinstance(l, list):
+        if not isinstance(listA, list):
             return None
-        length = len(l[0])
+        length = len(listA[0])
         transposed_list = []
         for i in range(length):
             tempRow = []
-            for j in range(len(l)):
-                tempRow.append(l[j][i])
+            for j in range(len(listA)):
+                tempRow.append(listA[j][i])
             transposed_list.append(tempRow)
         return transposed_list
     
     @staticmethod
-    def Trim(l):
+    def Trim(listA):
         """
         Trims the input nested list so that each sublist has the same number of members. All lists are trimmed to match the length of the shortest list.
         For example Trim([[1,2,3],['m','n','o','p'],['a','b','c','d','e']]) yields [[1, 2, 3], ['m', 'n', 'o'], ['a', 'b', 'c']]
 
         Parameters
         ----------
-        l : list
+        listA : list
             The input nested list.
 
         Returns
@@ -278,13 +317,13 @@ class Helper:
             The repeated list.
 
         """
-        minLength = len(l[0])
+        minLength = len(listA[0])
         returnList = []
-        for aSubList in l:
+        for aSubList in listA:
             newLength = len(aSubList)
             if newLength < minLength:
                 minLength = newLength
-        for anItem in l:
+        for anItem in listA:
             anItem = anItem[:minLength]
             returnList.append(anItem)
         return returnList

topologicpy/Plotly.py

@@ -391,7 +391,7 @@ class Plotly:
                        edgeMinGroup=None, edgeMaxGroup=None, 
                        showEdgeLegend=False, edgeLegendLabel="Topology Edges", edgeLegendRank=2, 
                        edgeLegendGroup=2,
-                       showFaces=True, faceOpacity=0.5, faceColor="white",
+                       showFaces=True, faceOpacity=0.5, faceColor="#FAFAFA",
                        faceLabelKey=None, faceGroupKey=None, faceGroups=[], 
                        faceMinGroup=None, faceMaxGroup=None, 
                        showFaceLegend=False, faceLegendLabel="Topology Faces", faceLegendRank=3,
@@ -478,7 +478,7 @@ class Plotly:
             - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
             - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
             - A named CSS color.
-            The default is "white".
+            The default is "#FAFAFA".
         faceLabelKey : str , optional
             The dictionary key to use to display the face label. The default is None.
         faceGroupKey : str , optional
@@ -677,7 +677,7 @@ class Plotly:
             return eData
 
 
-        def faceData(vertices, faces, dictionaries=None, color="white",
+        def faceData(vertices, faces, dictionaries=None, color="#FAFAFA",
                      opacity=0.5, labelKey=None, groupKey=None,
                      minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Faces",
                      legendGroup=3, legendRank=3, showLegend=True, intensities=None, colorScale="Viridis"):
@@ -786,7 +786,7 @@ class Plotly:
         data = []
         
         if showVertices:
-            tp_vertices = Topology.SubTopologies(topology, subTopologyType="vertex")
+            tp_vertices = Topology.Vertices(topology)
             if not (tp_vertices == None or tp_vertices == []):
                 vertices = []
                 v_dictionaries = []
@@ -812,7 +812,7 @@ class Plotly:
             intensities = None
             
         if showEdges and topology.Type() > topologic.Vertex.Type():
-            tp_edges = Topology.SubTopologies(topology, subTopologyType="edge")
+            tp_edges = Topology.Edges(topology)
             if not (tp_edges == None or tp_edges == []):
                 e_dictionaries = []
                 if edgeLabelKey or edgeGroupKey:
@@ -825,23 +825,24 @@ class Plotly:
                 data.append(edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, width=edgeWidth, labelKey=edgeLabelKey, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
         
         if showFaces and topology.Type() >= topologic.Face.Type():
-            tp_faces = Topology.SubTopologies(topology, subTopologyType="face")
+            if isinstance(topology, topologic.Face):
+                tp_faces = [topology]
+            else:
+                tp_faces = Topology.Faces(topology)
             if not(tp_faces == None or tp_faces == []):
                 f_dictionaries = []
                 all_triangles = []
                 for tp_face in tp_faces:
-                    shell = Topology.Triangulate(tp_face, transferDictionaries = False, tolerance=tolerance)
-                    if isinstance(shell, topologic.Face):
-                        triangles = [shell]
-                    else:
-                        triangles = Topology.SubTopologies(shell, subTopologyType="face")
+                    triangles = Face.Triangulate(tp_face, tolerance=tolerance)
                     for tri in triangles:
                         if faceLabelKey or faceGroupKey:
                             d = Topology.Dictionary(tp_face)
                             f_dictionaries.append(d)
                             if d:
                                 _ = Topology.SetDictionary(tri, d)
-                        all_triangles.append(tri)
+                        c = Topology.Centroid(tri)
+                        if Face.IsInternal(tp_face, c):
+                            all_triangles.append(tri)
                 if len(all_triangles) > 0:
                     f_cluster = Cluster.ByTopologies(all_triangles)
                     geo = Topology.Geometry(f_cluster, mantissa=mantissa)
@@ -1378,7 +1379,7 @@ class Plotly:
              showEdgeLegend=False, edgeLegendLabel="Topology Edges", edgeLegendRank=2, 
              edgeLegendGroup=2, 
 
-             showFaces=True, faceOpacity=0.5, faceColor="white",
+             showFaces=True, faceOpacity=0.5, faceColor="#FAFAFA",
              faceLabelKey=None, faceGroupKey=None, faceGroups=[], 
              faceMinGroup=None, faceMaxGroup=None, 
              showFaceLegend=False, faceLegendLabel="Topology Faces", faceLegendRank=3,
@@ -1473,7 +1474,7 @@ class Plotly:
             - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
             - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
             - A named CSS color.
-            The default is "white".
+            The default is "#FAFAFA".
         faceLabelKey : str , optional
             The dictionary key to use to display the face label. The default is None.
         faceGroupKey : str , optional