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

topologicpy/CellComplex.py

@@ -48,6 +48,99 @@ except:
         warnings.warn("CellComplex - Error: Could not import scipy.")
 
 class CellComplex():
+    @staticmethod
+    def AdjacencyDictionary(cellComplex, cellLabelKey: str = None,  faceKey: str = None, includeWeights: bool = False, reverse: bool = False, mantissa: int = 6, silent: bool = False):
+        """
+        Returns the adjacency dictionary of the input Graph.
+
+        Parameters
+        ----------
+        cellComplex : topologic_core.CellComplex
+            The input cellComplex.
+        cellLabelKey : str , optional
+            The returned cells are labelled according to the dictionary values stored under this key.
+            If the cellLabelKey does not exist, it will be created and the cells are labelled numerically and stored in the vertex dictionary under this key. The default is None.
+        faceKey : str , optional
+            If set, the faces' dictionaries will be searched for this key to set their weight. If the key is set to "Area" (case insensitive), the area of the shared faces will be used as its weight. If set to None, a weight of 1 will be used. The default is None.
+        includeWeights : bool , optional
+            If set to True, edge weights are included. Otherwise, they are not. The default is False.
+        reverse : bool , optional
+                If set to True, the cells are sorted in reverse order (only if cellLabelKey is set). Otherwise, they are not. The default is False.
+
+        silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        dict
+            The adjacency dictionary.
+        """
+        from topologicpy.Face import Face
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        if not Topology.IsInstance(cellComplex, "CellComplex"):
+            if not silent:
+                print("CellComplex.AdjacencyDictionary - Error: The input cellComplex input parameter is not a valid cellComplex. Returning None.")
+            return None
+        if cellLabelKey == None:
+            cellLabelKey = "__label__"
+        if not isinstance(cellLabelKey, str):
+            if not silent:
+                print("CellComplex.AdjacencyDictionary - Error: The input cellLabelKey is not a valid string. Returning None.")
+            return None
+        all_cells = Topology.Cells(cellComplex)
+        labels = []
+        n = max(len(str(len(all_cells))), 3)
+        for i, cell in enumerate(all_cells):
+            d = Topology.Dictionary(cell)
+            value = Dictionary.ValueAtKey(d, cellLabelKey)
+            if value == None:
+                value = str(i+1).zfill(n)
+            if d == None:
+                d = Dictionary.ByKeyValue(cellLabelKey, value)
+            else:
+                d = Dictionary.SetValueAtKey(d, cellLabelKey, value)
+            cell = Topology.SetDictionary(cell, d)
+            labels.append(value)
+        all_cells = Helper.Sort(all_cells, labels)
+        labels.sort()
+        order = len(all_cells)
+        adjDict = {}
+        for i in range(order):
+            cell = all_cells[i]
+            cell_label = labels[i]
+            adjCells = Topology.AdjacentTopologies(cell, hostTopology=cellComplex, topologyType="cell")
+            temp_list = []
+            for adjCell in adjCells:
+                adj_label = Dictionary.ValueAtKey(Topology.Dictionary(adjCell), cellLabelKey)
+                adj_index = labels.index(adj_label)
+                if includeWeights == True:
+                    if faceKey == None:
+                        weight = 1
+                    elif "area" in faceKey.lower():
+                        shared_topologies = Topology.SharedTopologies(cell, adjCell)
+                        faces = shared_topologies.get("faces", [])
+                        weight = sum([Face.Area(face, mantissa=mantissa) for face in faces])
+                    else:
+                        shared_topologies = Topology.SharedTopologies(cell, adjCell)
+                        faces = shared_topologies.get("faces", [])
+                        weight = sum([Dictionary.ValueAtKey(Topology.Dictionary(face),faceKey, 0) for face in faces])
+                    if not adj_index == None:
+                        temp_list.append((adj_label, weight))
+                else:
+                    if not adj_index == None:
+                        temp_list.append(adj_label)
+            temp_list.sort()
+            adjDict[cell_label] = temp_list
+        if cellLabelKey == "__label__": # This is label we added, so remove it
+            for cell in all_cells:
+                d = Topology.Dictionary(cell)
+                d = Dictionary.RemoveKey(d, cellLabelKey)
+                cell = Topology.SetDictionary(cell, d)
+        return adjDict
+
     @staticmethod
     def Box(origin= None,
             width: float = 1.0, length: float = 1.0, height: float = 1.0,
@@ -159,7 +252,7 @@ class CellComplex():
             if transferDictionaries == True:
                 for temp_cell in temp_cells:
                     v = Topology.InternalVertex(temp_cell, tolerance=tolerance)
-                    enclosing_cells = Vertex.EnclosingCell(v, cluster)
+                    enclosing_cells = Vertex.EnclosingCells(v, cluster)
                     dictionaries = [Topology.Dictionary(ec) for ec in enclosing_cells]
                     d = Dictionary.ByMergedDictionaries(dictionaries, silent=silent)
                     temp_cell = Topology.SetDictionary(temp_cell, d)
@@ -1050,6 +1143,125 @@ class CellComplex():
         shells = Topology.Shells(cellComplex)
         return shells
 
+
+    def _grow_connected_group(seed_idx, group_size, adjacency, visited_global):
+        """
+        Attempts to grow a group of the given size starting from seed_idx using adjacency.
+        Returns a list of indices if successful, else None.
+        """
+        from collections import deque
+        import random
+
+        group = [seed_idx]
+        visited = set(group)
+        queue = deque([seed_idx])
+
+        while queue and len(group) < group_size:
+            current = queue.popleft()
+            neighbors = adjacency.get(current, [])
+            random.shuffle(neighbors)
+            for neighbor in neighbors:
+                if neighbor not in visited and neighbor not in visited_global:
+                    group.append(neighbor)
+                    visited.add(neighbor)
+                    queue.append(neighbor)
+                    if len(group) >= group_size:
+                        break
+
+        return group if len(group) == group_size else None
+
+    def SubCombinations(cellComplex,
+                        minCells: int = 2,
+                        maxCells: int = None,
+                        maxCombinations: int = 100,
+                        timeLimit: int = 10,
+                        silent: bool = False):
+        """
+        Creates sub-combination cellComplexes of the input cellComplex. Warning: This is prone to combinatorial explosion.
+
+        Parameters
+        ----------
+        cellComplex : topologic_core.cellComplex
+            The input cellComplex
+        minCells : int , optional
+            The minimum number of cells to include in a combination. The default is 2.
+        maxCells : int , optional
+            The maximum number of cells to include in a combinations. The default is None which means the maximum will be set to the number of cells in the cellComplex minus 1.
+        maxCombinations : int , optional
+            The maximum number of combinations to create. The default is 100.
+        timeLimit : int , optional
+                The time limit in seconds. The default is 10 seconds. Note that this time limit only applies to creating the combination indices and not the actual CellComplexes.
+        tolerance : float , optional
+            The tolerance for computing if the input vertex is external to the input topology. 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
+        -------
+        list
+            The list of created CellComplex sub-combinations.
+
+        """
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        import random
+        import time
+
+        if not Topology.IsInstance(cellComplex, "CellComplex"):
+            if not silent:
+                print("CellComplex.SubCombinations - Error: The cellComplex input parameter is not a valid cellComplex. Returning None.")
+            return None
+
+        
+        start_time = time.time()
+        all_cells = CellComplex.Cells(cellComplex)
+        num_cells = len(all_cells)
+        indices = list(range(num_cells))
+        cell_label_key = "index"
+        # 1. Assign a unique index to each cell's dictionary
+        all_cells = [Topology.SetDictionary(cell, Dictionary.ByKeyValue(cell_label_key, i)) for i, cell in enumerate(all_cells)]
+        if maxCells == None:
+            maxCells = len(all_cells) - 1
+        # 2. Allocate counts per group size
+        group_sizes = list(range(minCells, maxCells + 1))
+        combinations_per_size = maxCombinations // len(group_sizes)
+
+        # 3. Build adjacency dict
+        adjacency = CellComplex.AdjacencyDictionary(cellComplex, cellLabelKey=cell_label_key, faceKey=None, includeWeights=False)
+
+        results = []
+        seen_groups = set()  # sets of sorted indices
+
+        # 4. Start from longest group size
+        for group_size in reversed(group_sizes):
+            remaining = combinations_per_size
+            tries = 0
+            max_tries = combinations_per_size * 10  # fallback guard
+            while remaining > 0 and time.time() - start_time < timeLimit and tries < max_tries:
+                random.shuffle(indices)
+                for seed in indices:
+                    if time.time() - start_time > timeLimit:
+                        break
+                    group = CellComplex._grow_connected_group(seed, group_size, adjacency, visited_global=seen_groups)
+                    if group:
+                        key = tuple(sorted(group))
+                        if key not in seen_groups:
+                            tries += 1
+                            seen_groups.add(key)
+                            results.append(group)
+                            remaining -= 1
+                    if remaining <= 0 or tries >= max_tries:
+                        break
+        # 5. Build CellComplex SubCombinations
+        return_combinations = []
+        for i, result in enumerate(reversed(results)):
+            cells = [all_cells[i] for i in result]
+            combination = Topology.SelfMerge(Cluster.ByTopologies(cells))
+            if Topology.IsInstance(combination, "CellComplex"):
+                return_combinations.append(combination)
+        return return_combinations
+
     @staticmethod
     def Tetrahedron(origin = None, length: float = 1, depth: int = 1, direction=[0,0,1], placement="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """

topologicpy/Cluster.py

@@ -1105,7 +1105,7 @@ class Cluster():
         return Cluster.ByTopologies(cellComplexes+cells)
     
     @staticmethod
-    def MysticRose(wire= None, origin= None, radius: float = 0.5, sides: int = 16, perimeter: bool = True, direction: list = [0, 0, 1], placement:str = "center", tolerance: float = 0.0001):
+    def MysticRose(wire= None, origin= None, radius: float = 0.5, sides: int = 16, perimeter: bool = True, direction: list = [0, 0, 1], placement:str = "center", tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a mystic rose.
 
@@ -1127,6 +1127,8 @@ class Cluster():
             The description of the placement of the origin of the mystic rose. This can be "center", or "lowerleft". 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
         -------
@@ -1153,7 +1155,7 @@ class Cluster():
         if perimeter:
             edges = Wire.Edges(wire)
         for comb in combs:
-            edges.append(Edge.ByVertices([vertices[comb[0]], vertices[comb[1]]], tolerance=tolerance))
+            edges.append(Edge.ByVertices([vertices[comb[0]], vertices[comb[1]]], tolerance=tolerance, silent=silent))
         return Cluster.ByTopologies(edges)
     
     @staticmethod

topologicpy/Edge.py

@@ -114,7 +114,7 @@ class Edge():
         return round(ang, mantissa)
 
     @staticmethod
-    def Bisect(edgeA, edgeB, length: float = 1.0, placement: int = 0, tolerance: float = 0.0001):
+    def Bisect(edgeA, edgeB, length: float = 1.0, placement: int = 0, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a bisecting edge between edgeA and edgeB.
 
@@ -134,6 +134,8 @@ class Edge():
             If set to any number other than 0, 1, or 2, the bisecting edge centroid will be placed at the end vertex of the first edge. The default is 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
         -------
@@ -171,29 +173,34 @@ class Edge():
             return edge1, edge2
         
         if not Topology.IsInstance(edgeA, "Edge"):
-            print("Edge.Bisect - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.Bisect - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
             return None
         if not Topology.IsInstance(edgeB, "Edge"):
-            print("Edge.Bisect - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.Bisect - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
             return None
         if Edge.Length(edgeA) <= tolerance:
-            print("Edge.Bisect - Error: The input edgeA parameter is shorter than the input tolerance parameter. Returning None.")
+            if not silent:
+                print("Edge.Bisect - Error: The input edgeA parameter is shorter than the input tolerance parameter. Returning None.")
             return None
         if Edge.Length(edgeB) <= tolerance:
-            print("Edge.Bisect - Error: The input edgeB parameter is shorter than the input tolerance parameter. Returning None.")
+            if not silent:
+                print("Edge.Bisect - Error: The input edgeB parameter is shorter than the input tolerance parameter. Returning None.")
             return None
         
         
         edge1, edge2 = process_edges(edgeA, edgeB, tolerance=tolerance)
         if edge1 == None or edge2 == None:
-            print("Edge.Bisect - Error: The input edgeA and edgeB parameters do not share a vertex and thus cannot be bisected. Returning None.")
+            if not silent:
+                print("Edge.Bisect - Error: The input edgeA and edgeB parameters do not share a vertex and thus cannot be bisected. Returning None.")
             return None
         sv = Edge.StartVertex(edge1)
         dir1 = Edge.Direction(edge1)
         dir2 = Edge.Direction(edge2)
         bisecting_vector = Vector.Bisect(dir1, dir2)
         ev = Topology.TranslateByDirectionDistance(sv, bisecting_vector, length)
-        bisecting_edge = Edge.ByVertices([sv, ev])
+        bisecting_edge = Edge.ByVertices([sv, ev], tolerance=tolerance, silent=silent)
         if placement == 0:
             bisecting_edge = Topology.TranslateByDirectionDistance(bisecting_edge, Vector.Reverse(bisecting_vector), length*0.5)
         elif placement == 2:
@@ -299,29 +306,45 @@ class Edge():
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        import inspect
         
         edge = None
         if not Topology.IsInstance(vertexA, "Vertex"):
             if not silent:
                 print("Edge.ByStartVertexEndVertex - Error: The input vertexA parameter is not a valid topologic vertex. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if not Topology.IsInstance(vertexB, "Vertex"):
             if not silent:
                 print("Edge.ByStartVertexEndVertex - Error: The input vertexB parameter is not a valid topologic vertex. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if Topology.IsSame(vertexA, vertexB):
             if not silent:
                 print("Edge.ByStartVertexEndVertex - Error: The input vertexA and vertexB parameters are the same vertex. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if Vertex.Distance(vertexA, vertexB) <= tolerance:
             if not silent:
                 print("Edge.ByStartVertexEndVertex - Error: The distance between the input vertexA and vertexB parameters is less than the input tolerance. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         try:
             edge = topologic.Edge.ByStartVertexEndVertex(vertexA, vertexB)  # Hook to Core
         except:
             if not silent:
                 print("Edge.ByStartVertexEndVertex - Error: Could not create an edge. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             edge = None
         return edge
     
@@ -366,7 +389,7 @@ class Edge():
             return None
 
         endVertex = Topology.TranslateByDirectionDistance(origin, direction=direction[:3], distance=length)
-        edge = Edge.ByVertices(origin, endVertex, tolerance=tolerance)
+        edge = Edge.ByVertices(origin, endVertex, tolerance=tolerance, silent=silent)
         return edge
 
     @staticmethod
@@ -472,11 +495,11 @@ class Edge():
             The first input edge. This edge will be extended to meet edgeB.
         edgeB : topologic_core.Edge
             The second input edge. This edge will be used to extend edgeA.
-        silent : bool , optional
-            If set to True, no error and warning messages are printed. Otherwise, they are. 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
         -------
         topologic_core.Edge or topologic_core.Wire
@@ -496,7 +519,7 @@ class Edge():
             distances.append(Vertex.Distance(pair[0], pair[1]))
         v_list = Helper.Sort(v_list, distances)
         closest_pair = v_list[0]
-        return_edge = Edge.ByVertices(closest_pair, silent=silent)
+        return_edge = Edge.ByVertices(closest_pair, tolerance=tolerance, silent=silent)
         if return_edge == None:
             if not silent:
                 print("Edge.ConnectToEdge - Warning: Could not connect the two edges. Returning None.")
@@ -617,7 +640,7 @@ class Edge():
 
 
     @staticmethod
-    def Extend(edge, distance: float = 1.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001):
+    def Extend(edge, distance: float = 1.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         Extends the input edge by the input distance.
 
@@ -633,6 +656,8 @@ class Edge():
             If set to True, the edge will be extended from its start vertex. Otherwise, it will be extended from its end vertex. 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
         -------
@@ -659,7 +684,7 @@ class Edge():
         else:
             sve = Edge.StartVertex(edge)
             eve = Edge.VertexByDistance(edge, distance=distance, origin=ev, tolerance=tolerance)
-        return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=True)
+        return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=silent)
 
     @staticmethod
     def ExtendToEdge(edgeA, edgeB, mantissa: int = 6, step: bool = True, tolerance: float = 0.0001, silent: bool = False):
@@ -728,14 +753,14 @@ class Edge():
         
         d = max(d1, d2)*2
         v2 = Topology.TranslateByDirectionDistance(v2, direction=edge_direction, distance=d)
-        new_edge = Edge.ByVertices(v1, v2)
+        new_edge = Edge.ByVertices([v1, v2], tolerance=tolerance, silent=silent)
         
         svb = Edge.StartVertex(edgeB)
         evb = Edge.EndVertex(edgeB)
 
         intVertex = Topology.Intersect(new_edge, edgeB, tolerance=tolerance)
         if intVertex:
-            return Edge.ByVertices([v1, intVertex], tolerance=tolerance, silent=True)
+            return Edge.ByVertices([v1, intVertex], tolerance=tolerance, silent=silent)
         if not silent:
             print("Edge.ExtendToEdge - Warning: The operation failed. Connecting the edges instead. Returning a Wire.")
         return Edge.ConnectToEdge(edgeA, edgeB, tolerance=tolerance)
@@ -1323,7 +1348,7 @@ class Edge():
         return normal_edge
 
     @staticmethod
-    def Normalize(edge, useEndVertex: bool = False, tolerance: float = 0.0001):
+    def Normalize(edge, useEndVertex: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a normalized edge that has the same direction as the input edge, but a length of 1.
 
@@ -1335,6 +1360,8 @@ class Edge():
             If True the normalized edge end vertex will be placed at the end vertex of the input edge. Otherwise, the normalized edge start vertex will be placed at the start vertex of the input edge. 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
         -------
@@ -1345,7 +1372,8 @@ class Edge():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(edge, "Edge"):
-            print("Edge.Normalize - Error: The input edge parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.Normalize - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
         if not useEndVertex:
             sv = Edge.StartVertex(edge)
@@ -1353,7 +1381,7 @@ class Edge():
         else:
             sv = Edge.VertexByDistance(edge, 1.0, Edge.StartVertex(edge))
             ev = Edge.EndVertex(edge)
-        return Edge.ByVertices([sv, ev], tolerance=tolerance)
+        return Edge.ByVertices([sv, ev], tolerance=tolerance, silent=silent)
 
     @staticmethod
     def ParameterAtVertex(edge, vertex, mantissa: int = 6, silent: bool = False) -> float:
@@ -1395,7 +1423,7 @@ class Edge():
         return round(parameter, mantissa)
 
     @staticmethod
-    def Reverse(edge, tolerance: float = 0.0001):
+    def Reverse(edge, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates an edge that has the reverse direction of the input edge.
 
@@ -1405,6 +1433,8 @@ class Edge():
             The input edge.
         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
         -------
@@ -1415,9 +1445,10 @@ class Edge():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(edge, "Edge"):
-            print("Edge.Reverse - Error: The input edge parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.Reverse - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
-        return Edge.ByVertices([Edge.EndVertex(edge), Edge.StartVertex(edge)], tolerance=tolerance)
+        return Edge.ByVertices([Edge.EndVertex(edge), Edge.StartVertex(edge)], tolerance=tolerance, silent=silent)
     
     @staticmethod
     def SetLength(edge , length: float = 1.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001):
@@ -1482,7 +1513,7 @@ class Edge():
         return vert
 
     @staticmethod
-    def Trim(edge, distance: float = 0.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001):
+    def Trim(edge, distance: float = 0.0, bothSides: bool = True, reverse: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
         Trims the input edge by the input distance.
 
@@ -1498,6 +1529,8 @@ class Edge():
             If set to True, the edge will be trimmed from its start vertex. Otherwise, it will be trimmed from its end vertex. 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
         -------
@@ -1527,7 +1560,7 @@ class Edge():
         else:
             sve = Edge.StartVertex(edge)
             eve = Edge.VertexByDistance(edge, distance=-distance, origin=ev, tolerance=tolerance)
-        return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=True)
+        return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=silent)
 
     @staticmethod
     def TrimByEdge(edgeA, edgeB, reverse: bool = False, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
@@ -1587,9 +1620,9 @@ class Edge():
                 intVertex = None
             if intVertex:
                 if reverse:
-                        return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=True)
+                        return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=silent)
                 else:
-                    return Edge.ByVertices([sva, intVertex], tolerance=tolerance, silent=True)
+                    return Edge.ByVertices([sva, intVertex], tolerance=tolerance, silent=silent)
             else:
                 return None
         
@@ -1598,9 +1631,9 @@ class Edge():
         intVertex = Topology.Intersect(edgeA, edgeB)
         if intVertex and (Vertex.IsInternal(intVertex, edgeA)):
             if reverse:
-                return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=True)
+                return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=slient)
             else:
-                return Edge.ByVertices([sva, intVertex], tolerance=tolerance, silent=True)
+                return Edge.ByVertices([sva, intVertex], tolerance=tolerance, silent=silent)
         return edgeA
 
     @staticmethod