topologicpy 0.7.84__py3-none-any.whl → 0.7.86__py3-none-any.whl

topologicpy/Grid.py

@@ -86,7 +86,7 @@ class Grid():
             uRange.sort()
             uuVector = Vector.Normalize(uVector)
             for u in uRange:
-                tempVec = Vector.Multiply(uuVector, u, tolerance)
+                tempVec = Vector.Multiply(uuVector, u, tolerance=tolerance)
                 v1 = Vertex.ByCoordinates(Vertex.X(uOrigin, mantissa=mantissa)+tempVec[0], Vertex.Y(uOrigin, mantissa=mantissa)+tempVec[1], Vertex.Z(uOrigin, mantissa=mantissa)+tempVec[2])
                 v2 = Vertex.ByCoordinates(Vertex.X(v1, mantissa=mantissa)+vVector[0], Vertex.Y(v1, mantissa=mantissa)+vVector[1], Vertex.Z(v1, mantissa=mantissa)+vVector[2])
                 e = Edge.ByVertices([v1, v2], tolerance=tolerance)
@@ -107,7 +107,7 @@ class Grid():
             vRange.sort()
             uvVector = Vector.Normalize(vVector)
             for v in vRange:
-                tempVec = Vector.Multiply(uvVector, v, tolerance)
+                tempVec = Vector.Multiply(uvVector, v, tolerance=tolerance)
                 v1 = Vertex.ByCoordinates(Vertex.X(vOrigin, mantissa=mantissa)+tempVec[0], Vertex.Y(vOrigin, mantissa=mantissa)+tempVec[1], Vertex.Z(vOrigin, mantissa=mantissa)+tempVec[2])
                 v2 = Vertex.ByCoordinates(Vertex.X(v1, mantissa=mantissa)+uVector[0], Vertex.Y(v1, mantissa=mantissa)+uVector[1], Vertex.Z(v1, mantissa=mantissa)+uVector[2])
                 e = Edge.ByVertices([v1, v2], tolerance=tolerance)
@@ -282,8 +282,8 @@ class Grid():
             uvVector = Vector.Normalize(vVector)
             for u in uRange:
                 for v in vRange:
-                    uTempVec = Vector.Multiply(uuVector, u, tolerance)
-                    vTempVec = Vector.Multiply(uvVector, v, tolerance)
+                    uTempVec = Vector.Multiply(uuVector, u, tolerance=tolerance)
+                    vTempVec = Vector.Multiply(uvVector, v, tolerance=tolerance)
                     gridVertex = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+uTempVec[0], Vertex.Y(origin, mantissa=mantissa)+vTempVec[1], Vertex.Z(origin, mantissa=mantissa)+uTempVec[2])
                     if clip and Topology.IsInstance(face, "Face"):
                         gridVertex = gridVertex.Intersect(face, False)

topologicpy/Helper.py

@@ -580,4 +580,45 @@ class Helper:
             The current version of the software.
 
         """
-        return topologicpy.__version__
+        
+        import requests
+        from packaging import version
+
+        def compare_version_with_pypi(library_name, input_version):
+            """
+            Compare an input version with the latest version of a Python library on PyPI.
+
+            Args:
+                library_name (str): The name of the Python library on PyPI.
+                input_version (str): The version number to compare (e.g., "0.7.58").
+
+            Returns:
+                str: A message indicating whether the input version is less than,
+                    equal to, or greater than the latest version on PyPI.
+            """
+            try:
+                # Fetch library data from PyPI
+                url = f"https://pypi.org/pypi/{library_name}/json"
+                response = requests.get(url)
+                response.raise_for_status()
+
+                # Extract the latest version from the JSON response
+                data = response.json()
+                latest_version = data['info']['version']
+
+                # Compare versions using the packaging library
+                if version.parse(input_version) < version.parse(latest_version):
+                    return (f"The version that you are using ({input_version}) is OLDER than the latest version {latest_version} from PyPI. Please consider upgrading to the latest version.")
+                elif version.parse(input_version) == version.parse(latest_version):
+                    return (f"The version that you are using ({input_version}) is the latest version available on PyPI.")
+                else:
+                    return (f"The version that you are using ({input_version}) is NEWER than the latest version ({latest_version}) available from PyPI.")
+
+            except requests.exceptions.RequestException as e:
+                return f"Error fetching data from PyPI: {e}"
+            except KeyError:
+                return "Error: Unable to find the latest version in the PyPI response."
+        
+        current_version = topologicpy.__version__
+        result = compare_version_with_pypi("topologicpy", current_version)
+        return result

topologicpy/Plotly.py

@@ -279,7 +279,7 @@ class Plotly:
                     angle: float = 0,
                     vertexColor: str = "black",
                     vertexColorKey: str = None,
-                    vertexSize: float = 6,
+                    vertexSize: float = 10,
                     vertexSizeKey: str = None,
                     vertexLabelKey: str = None,
                     vertexGroupKey: str = None,
@@ -292,7 +292,7 @@ class Plotly:
                     vertexLegendLabel="Graph Vertices",
                     vertexLegendRank=4, 
                     vertexLegendGroup=4,
-                    edgeColor: str = "black",
+                    edgeColor: str = "red",
                     edgeColorKey: str = None,
                     edgeWidth: float = 1,
                     edgeWidthKey: str = None,
@@ -498,8 +498,6 @@ class Plotly:
                 x.append(v[0])
                 y.append(v[1])
                 z.append(v[2])
-                label = " "
-                group = None
                 colors.append(Color.AnyToHex(color))
                 labels.append("Vertex_"+str(m+1).zfill(n))
                 sizes.append(size)
@@ -507,36 +505,37 @@ class Plotly:
                     d = dictionaries[m]
                     if d:
                         if not colorKey == None:
-                            colors[m] = Dictionary.ValueAtKey(d, key=colorKey) or colors[m]
+                            temp_color = Dictionary.ValueAtKey(d, key=colorKey)
+                            if not temp_color == None:
+                                colors[m] = Color.AnyToHex(temp_color)
                         if not labelKey == None:
                             labels[m] = str(Dictionary.ValueAtKey(d, key=labelKey)) or labels[m]
                         if not sizeKey == None:
                             sizes[m] = Dictionary.ValueAtKey(d, key=sizeKey) or sizes[m]
                         if not groupKey == None:
-                            colors[m] = Dictionary.ValueAtKey(d, key=groupKey) or colors[m]
-                    try:
-                        if type(colors[m]) == int or type(colors[m]) == float:
-                            if colors[m] < minGroup:
-                                colors[m] = minGroup
-                            if colors[m] > maxGroup:
-                                colors[m] = maxGroup
-                            temp_color = Color.ByValueInRange(colors[m], minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                            colors[m] = Color.AnyToHEX(temp_color)
-
-                        else:
-                            temp_color = Color.ByValueInRange(groups.index(colors[m]), minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                            colors[m] = Color.AnyToHex(temp_color)
-                    except:
-                        #groupList.append(Color.AnyToHex([0,0,0]))
-                        pass
+                            c_value = Dictionary.ValueAtKey(d, key=groupKey)
+                            if not c_value == None:
+                                if type(c_value) == int or type(c_value) == float:
+                                    if c_value < minGroup:
+                                        c_value = minGroup
+                                    if c_value > maxGroup:
+                                        c_value = maxGroup
+                                    temp_color = Color.ByValueInRange(c_value,
+                                                                        minValue=minGroup,
+                                                                        maxValue=maxGroup,
+                                                                        colorScale=colorScale)
+                                    colors[m] = Color.AnyToHex(temp_color)
+                                elif isinstance(c_value, str):
+                                    temp_color = Color.ByValueInRange(groups.index(c_value), minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
+                                    colors[m] = Color.AnyToHex(temp_color)
         else:
             for v in vertices:
                 x.append(v[0])
                 y.append(v[1])
                 z.append(v[2])
         
-        if len(list(set(colors))) < 2:
-            colors = Color.AnyToHex(color)
+        # if len(list(set(colors))) < 2:
+        #     colors = Color.AnyToHex(color)
         if len(labels) < 1:
             labels = "Vertex_1"
         if len(sizes) < 1:
@@ -903,7 +902,7 @@ class Plotly:
                     label = ""
                     group = None
                     groupList.append(Color.AnyToHex(color)) # Store a default color for that face
-                    labels.append("Mace_"+str(m+1).zfill(n))
+                    labels.append("Face_"+str(m+1).zfill(n))
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:

topologicpy/Shell.py

@@ -1008,7 +1008,7 @@ class Shell():
         v3 = Vertex.ByCoordinates(x3,y3,z3)
         f1 = Face.ByVertices([v2,v1,v3])
         faces.append(f1)
-        returnTopology = Shell.ByFaces(faces, tolerance)
+        returnTopology = Shell.ByFaces(faces, tolerance=tolerance)
         if not returnTopology:
             returnTopology = Cluster.ByTopologies(faces)
         vertices = []
@@ -1745,7 +1745,7 @@ class Shell():
 
             return numerator / denominator
 
-        def douglas_peucker(wire, tolerance):
+        def douglas_peucker(wire, tolerance=0.0001):
             if isinstance(wire, list):
                 points = wire
             else:
@@ -1773,8 +1773,8 @@ class Shell():
                 return [start_point, end_point]
 
             # Recursively simplify
-            first_segment = douglas_peucker(points[:max_index + 1], tolerance)
-            second_segment = douglas_peucker(points[max_index:], tolerance)
+            first_segment = douglas_peucker(points[:max_index + 1], tolerance=tolerance)
+            second_segment = douglas_peucker(points[max_index:], tolerance=tolerance)
 
             # Merge the two simplified segments
             return first_segment[:-1] + second_segment
@@ -1819,7 +1819,7 @@ class Shell():
         separators = Helper.Flatten(separators)
         results = []
         for w in wires:
-            temp_wire = Wire.ByVertices(douglas_peucker(w, tolerance), close=False)
+            temp_wire = Wire.ByVertices(douglas_peucker(w, tolerance=tolerance), close=False)
             results.append(temp_wire)
         # Make a Cluster out of the results
         cluster = Cluster.ByTopologies(results)

topologicpy/Topology.py

@@ -286,7 +286,7 @@ class Topology():
                     usedTopologies.append(0)
             ap = 1
             for aperture in apertures:
-                apCenter = Topology.InternalVertex(aperture, tolerance)
+                apCenter = Topology.InternalVertex(aperture, tolerance=tolerance)
                 for i in range(len(subTopologies)):
                     subTopology = subTopologies[i]
                     if exclusive == True and usedTopologies[i] == 1:
@@ -319,7 +319,7 @@ class Topology():
             subTopologies = [topology]
         else:
             subTopologies = Topology.SubTopologies(topology, subTopologyType)
-        processApertures(subTopologies, apertures, exclusive, tolerance)
+        processApertures(subTopologies, apertures, exclusive, tolerance=tolerance)
         return topology
     
     @staticmethod
@@ -1524,7 +1524,7 @@ class Topology():
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Cluster import Cluster
 
-        def topologyByFaces(faces, topologyType, tolerance):
+        def topologyByFaces(faces, topologyType, tolerance=0.0001):
             if len(faces) == 1:
                 return faces[0]
 
@@ -1663,7 +1663,7 @@ class Topology():
             The created topology. The topology will have a dictionary embedded in it that records the input attributes (color, id, lengthUnit, name, type)
 
         """
-        def topologyByFaces(faces, outputMode, tolerance):
+        def topologyByFaces(faces, outputMode, tolerance=0.0001):
             output = None
             if len(faces) == 1:
                 return faces[0]
@@ -2386,6 +2386,10 @@ class Topology():
 
         import ifcopenshell, ifcopenshell.geom
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Face import Face
+        import numpy as np
 
         def get_psets(entity):
             # Initialize the PSET dictionary for this entity
@@ -2506,47 +2510,55 @@ class Topology():
                 color = (random.random(), random.random(), random.random())
             
             return color, default_transparency, material_list
-        
+        # Create a 4x4 unity matrix
+        matrix = [[1.0 if i == j else 0.0 for j in range(4)] for i in range(4)]
         def convert_to_topology(entity, settings, transferDictionaries=False):    
             if hasattr(entity, "Representation") and entity.Representation:
                 for rep in entity.Representation.Representations:
                     if rep.is_a("IfcShapeRepresentation"):
                         # Generate the geometry for this entity
                         shape = ifcopenshell.geom.create_shape(settings, entity)
-                        shape_geometry = shape.geometry
-                        verts = shape_geometry.verts
-                        verts = [ [verts[i], verts[i + 1], verts[i + 2]] for i in range(0, len(verts), 3)]
-                        edges = shape_geometry.edges
-                        edges = [[edges[i], edges[i + 1]] for i in range(0, len(edges), 2)]
-                        faces = shape_geometry.faces
-                        faces = [ [faces[i], faces[i + 1], faces[i + 2]] for i in range(0, len(faces), 3)]
-                        # Convert geometry to Topologic format
+                        try:
+                            trans = shape.transformation
+                            # Convert into a 4x4 matrix
+                            matrix = [trans.matrix[i:i+4] for i in range(0, len(trans.matrix), 4)]
+                        except:
+                            pass
+                        # Get grouped vertices and grouped faces     
+                        grouped_verts = shape.geometry.verts
+                        verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
+                        grouped_edges = shape.geometry.edges
+                        edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
+                        grouped_faces = shape.geometry.faces
+                        faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
                         #shape_topology = ifc_to_topologic_geometry(verts, edges, faces)
                         #shape_topology = Topology.SelfMerge(Topology.ByGeometry(verts, edges, faces))
                         shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
-                        if removeCoplanarFaces == True:
-                            shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
-
-                        # Store relevant information
-                        if transferDictionaries == True:
-                            color, transparency, material_list = get_color_transparency_material(entity)
-                            entity_dict = {
-                                "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
-                                "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
-                                "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
-                                "TOPOLOGIC_color": color,
-                                "TOPOLOGIC_opacity": 1.0 - transparency,
-                                "IFC_global_id": getattr(entity, 'GlobalId', 0),
-                                "IFC_name": getattr(entity, 'Name', "Untitled"),
-                                "IFC_type": entity.is_a(),
-                                "IFC_material_list": material_list,
-                            }
-                            topology_dict = Dictionary.ByPythonDictionary(entity_dict)
-                            # Get PSETs dictionary
-                            pset_python_dict = get_psets(entity)
-                            pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
-                            topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
-                            shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
+                        if not shape_topology == None:
+                            if removeCoplanarFaces == True:
+                                shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+                            shape_topology = Topology.Transform(shape_topology, matrix)
+
+                            # Store relevant information
+                            if transferDictionaries == True:
+                                color, transparency, material_list = get_color_transparency_material(entity)
+                                entity_dict = {
+                                    "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
+                                    "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
+                                    "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
+                                    "TOPOLOGIC_color": color,
+                                    "TOPOLOGIC_opacity": 1.0 - transparency,
+                                    "IFC_global_id": getattr(entity, 'GlobalId', 0),
+                                    "IFC_name": getattr(entity, 'Name', "Untitled"),
+                                    "IFC_type": entity.is_a(),
+                                    "IFC_material_list": material_list,
+                                }
+                                topology_dict = Dictionary.ByPythonDictionary(entity_dict)
+                                # Get PSETs dictionary
+                                pset_python_dict = get_psets(entity)
+                                pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
+                                topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
+                                shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
                         return shape_topology
             return None
 
@@ -6228,7 +6240,7 @@ class Topology():
             return Topology.Type(topology)
 
     @staticmethod
-    def InternalVertex(topology, tolerance: float = 0.0001):
+    def _InternalVertex(topology, tolerance: float = 0.0001):
         """
         Returns a vertex guaranteed to be inside the input topology.
 
@@ -6283,11 +6295,54 @@ class Topology():
         elif Topology.IsInstance(top, "Vertex"): #Vertex
             vst = top
         elif Topology.IsInstance(topology, "Aperture"): #Aperture
-            vst = Face.InternalVertex(Aperture.Topology(top), tolerance)
+            vst = Face.InternalVertex(Aperture.Topology(top), tolerance=tolerance)
         else:
             vst = Topology.Centroid(top)
         return vst
 
+    
+
+    @staticmethod
+    def InternalVertex(topology, timeout: int = 10, tolerance: float = 0.0001):
+        """
+        Returns a vertex guaranteed to be inside the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        timeout : int , optional
+            The amount of seconds to wait before timing out. The default is 10 seconds.
+        tolerance : float , ptional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Vertex
+            A vertex guaranteed to be inside the input topology.
+
+        """
+        import concurrent.futures
+        import time
+        # Wrapper function with timeout
+        def run_with_timeout(func, topology, tolerance=0.0001, timeout=10):
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(func, topology, tolerance=tolerance)
+                try:
+                    result = future.result(timeout=timeout)  # Wait for the result with a timeout
+                    return result
+                except concurrent.futures.TimeoutError:
+                    print("Function took too long, retrying with a different solution.")
+                    return None  # or try another approach here
+
+        result = run_with_timeout(Topology._InternalVertex, topology=topology, tolerance=tolerance, timeout=timeout)  # Set a 10 second timeout
+        if result is None:
+            # Handle failure case (e.g., try a different solution)
+            print("Using a different approach.")
+            result = Topology.Centroid(topology)
+            print("Result is:", result)
+        return result
+
     @staticmethod
     def IsInstance(topology, type: str):
         """
@@ -6371,7 +6426,7 @@ class Topology():
         """
         from topologicpy.Vertex import Vertex
 
-        def isOnPlane(v, plane, tolerance):
+        def isOnPlane(v, plane, tolerance=0.0001):
             x, y, z = v
             a, b, c, d = plane
             if math.fabs(a*x + b*y + c*z + d) <= tolerance:
@@ -6402,7 +6457,7 @@ class Topology():
         else:
             p = plane(vertices[0], vertices[1], vertices[2])
             for i in range(len(vertices)):
-                if isOnPlane([Vertex.X(vertices[i], mantissa=mantissa), Vertex.Y(vertices[i], mantissa=mantissa), Vertex.Z(vertices[i], mantissa=mantissa)], p, tolerance) == False:
+                if isOnPlane([Vertex.X(vertices[i], mantissa=mantissa), Vertex.Y(vertices[i], mantissa=mantissa), Vertex.Z(vertices[i], mantissa=mantissa)], p, tolerance=tolerance) == False:
                     result = False
                     break
         return result
@@ -7869,14 +7924,14 @@ class Topology():
     @staticmethod
     def Show(*topologies,
              opacityKey = "opacity",
-             showVertices=True, vertexSize=1.1, vertexSizeKey = None, vertexColor="black", vertexColorKey = None,
+             showVertices=True, vertexSize=None, vertexSizeKey = None, vertexColor="black", vertexColorKey = None,
              vertexLabelKey=None, showVertexLabel= False,
              vertexGroupKey=None, vertexGroups=[], 
              vertexMinGroup=None, vertexMaxGroup=None, 
              showVertexLegend=False, vertexLegendLabel="Topology Vertices", vertexLegendRank=1, 
              vertexLegendGroup=1, 
 
-             showEdges=True, edgeWidth=1, edgeWidthKey = None, edgeColor="black", edgeColorKey = None,
+             showEdges=True, edgeWidth=None, edgeWidthKey = None, edgeColor=None, edgeColorKey = None,
              edgeLabelKey=None, showEdgeLabel = False,
              edgeGroupKey=None, edgeGroups=[], 
              edgeMinGroup=None, edgeMaxGroup=None, 
@@ -7936,7 +7991,7 @@ class Topology():
             The list of vertex groups against which to index the color of the vertex. The default is [].
         vertexMinGroup : int or float , optional
             For numeric vertexGroups, vertexMinGroup is the desired minimum value for the scaling of colors. This should match the type of value associated with the vertexGroupKey. If set to None, it is set to the minimum value in vertexGroups. The default is None.
-        edgeMaxGroup : int or float , optional
+        vertexMaxGroup : int or float , optional
             For numeric vertexGroups, vertexMaxGroup is the desired maximum value for the scaling of colors. This should match the type of value associated with the vertexGroupKey. If set to None, it is set to the maximum value in vertexGroups. The default is None.
         showVertexLegend : bool, optional
             If set to True, the legend for the vertices of this topology is shown. Otherwise, it isn't. The default is False.
@@ -8105,23 +8160,78 @@ class Topology():
             if not silent:
                 print("Topology.Show - Error: the input topologies parameter does not contain any valid topology. Returning None.")
             return None
+        
         if camera[0] == 0 and camera[1] == 0 and up == [0,0,1]:
             up = [0,1,0] #default to positive Y axis being up if looking down or up at the XY plane
         data = []
         for topology in new_topologies:
             if Topology.IsInstance(topology, "Graph"):
-                data += Plotly.DataByGraph(topology, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexColorKey=vertexColorKey, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabel=showVertexLabel, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeColorKey=edgeColorKey, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabel=showEdgeLabel, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+                if vertexSize == None:
+                    vSize = 10
+                else:
+                    vSize = vertexSize
+                if edgeWidth == None:
+                    eWidth = 1
+                else:
+                    eWidth = edgeWidth
+                if edgeColor == None:
+                    eColor = "red"
+                else:
+                    eColor = edgeColor
+                data += Plotly.DataByGraph(topology,
+                                           sagitta=sagitta,
+                                           absolute=absolute,
+                                           sides=sides,
+                                           angle=angle,
+                                           vertexColor=vertexColor,
+                                           vertexColorKey=vertexColorKey,
+                                           vertexSize=vSize,
+                                           vertexSizeKey=vertexSizeKey,
+                                           vertexLabelKey=vertexLabelKey,
+                                           vertexGroupKey=vertexGroupKey,
+                                           vertexGroups=vertexGroups,
+                                           vertexMinGroup=vertexMinGroup,
+                                           vertexMaxGroup=vertexMaxGroup,
+                                           showVertices=showVertices,
+                                           showVertexLabel=showVertexLabel,
+                                           showVertexLegend=showVertexLegend,
+                                           edgeColor=eColor,
+                                           edgeColorKey=edgeColorKey,
+                                           edgeWidth=eWidth,
+                                           edgeWidthKey=edgeWidthKey,
+                                           edgeLabelKey=edgeLabelKey,
+                                           edgeGroupKey=edgeGroupKey,
+                                           edgeGroups=edgeGroups,
+                                           edgeMinGroup=edgeMinGroup,
+                                           edgeMaxGroup=edgeMaxGroup,
+                                           showEdges=showEdges,
+                                           showEdgeLabel=showEdgeLabel,
+                                           showEdgeLegend=showEdgeLegend,
+                                           colorScale=colorScale,
+                                           silent=silent)
             else:
+                if vertexSize == None:
+                    vSize = 1.1
+                else:
+                    vSize = vertexSize
+                if edgeWidth == None:
+                    eWidth = 1
+                else:
+                    eWidth = edgeWidth
+                if edgeColor == None:
+                    eColor = "black"
+                else:
+                    eColor = edgeColor
                 d = Topology.Dictionary(topology)
                 if not d == None:
                     faceOpacity = Dictionary.ValueAtKey(d, opacityKey) or faceOpacity
                 data += Plotly.DataByTopology(topology=topology,
-                            showVertices=showVertices, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexColor=vertexColor, vertexColorKey=vertexColorKey,
+                            showVertices=showVertices, vertexSize=vSize, vertexSizeKey=vertexSizeKey, vertexColor=vertexColor, vertexColorKey=vertexColorKey,
                             vertexLabelKey=vertexLabelKey, showVertexLabel=showVertexLabel, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, 
                             vertexMinGroup=vertexMinGroup, vertexMaxGroup=vertexMaxGroup, 
                             showVertexLegend=showVertexLegend, vertexLegendLabel=vertexLegendLabel, vertexLegendRank=vertexLegendRank,
                             vertexLegendGroup=vertexLegendGroup,
-                            showEdges=showEdges, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeColor=edgeColor, edgeColorKey=edgeColorKey,
+                            showEdges=showEdges, edgeWidth=eWidth, edgeWidthKey=edgeWidthKey, edgeColor=eColor, edgeColorKey=edgeColorKey,
                             edgeLabelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, 
                             edgeMinGroup=edgeMinGroup, edgeMaxGroup=edgeMaxGroup, 
                             showEdgeLegend=showEdgeLegend, edgeLegendLabel=edgeLegendLabel, edgeLegendRank=edgeLegendRank, 
@@ -8176,7 +8286,7 @@ class Topology():
             found = False
             for j in range(len(topologies)):
                 if usedTopologies[j] == 0:
-                    if Vertex.IsInternal( selectors[i], topologies[j], tolerance):
+                    if Vertex.IsInternal( selectors[i], topologies[j], tolerance=tolerance):
                         sortedTopologies.append(topologies[j])
                         if exclusive == True:
                             usedTopologies[j] = 1
@@ -8313,7 +8423,7 @@ class Topology():
                     returnTopology = Cell.ByShell(returnTopology)
                 except:
                     try:
-                        returnTopology = CellComplex.ByWires(topologies, tolerance)
+                        returnTopology = CellComplex.ByWires(topologies, tolerance=tolerance)
                         try:
                             returnTopology = CellComplex.ExternalBoundary(returnTopology)
                         except:
@@ -8340,7 +8450,7 @@ class Topology():
             for t in topologies:
                 external_wires.append(topologic.Face.ExternalBoundary(t))
             try:
-                returnTopology = CellComplex.ByWires(external_wires, tolerance)
+                returnTopology = CellComplex.ByWires(external_wires, tolerance=tolerance)
             except:
                 try:
                     returnTopology = Shell.ByWires(external_wires, triangulate=triangulate, tolerance=tolerance, silent=True)
@@ -8850,7 +8960,7 @@ class Topology():
         mergingProcess = MergingProcess(queue, sources_str, sink_items, so_dicts)
         mergingProcess.start()
 
-        workerProcessPool = WorkerProcessPool(numWorkers, queue, sources_str, sink_items, so_dicts, tolerance)
+        workerProcessPool = WorkerProcessPool(numWorkers, queue, sources_str, sink_items, so_dicts, tolerance=tolerance)
         workerProcessPool.startProcesses()
         workerProcessPool.join()
 

topologicpy/Vertex.py

@@ -771,7 +771,7 @@ class Vertex():
         from topologicpy.Topology import Topology
         import numpy as np
 
-        def fuse_vertices(vertices, tolerance):
+        def fuse_vertices(vertices, tolerance=0.0001):
             fused_vertices = []
             merged_indices = {}
 
@@ -818,7 +818,7 @@ class Vertex():
             return None
         
         vertices = [(Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa), Vertex.Z(v, mantissa=mantissa)) for v in vertices]
-        fused_vertices = fuse_vertices(vertices, tolerance)
+        fused_vertices = fuse_vertices(vertices, tolerance=tolerance)
         return_vertices = [Vertex.ByCoordinates(list(coord)) for coord in fused_vertices]
         return return_vertices