topologicpy 0.8.97__py3-none-any.whl → 0.8.98__py3-none-any.whl

topologicpy/BVH.py

@@ -342,12 +342,13 @@ class BVH:
         for topology in topologyList:
             if Topology.IsInstance(topology, "vertex"):
                 x,y,z = Vertex.Coordinates(topology, mantissa=mantissa)
-                points = [[x-tolerance, y-tolerance, z-tolerance], [x+tolerance, y+tolerance, z+tolerance]]
+                # points = [[x-tolerance, y-tolerance, z-tolerance], [x+tolerance, y+tolerance, z+tolerance]]
+                aabb_box = AABB(x-tolerance, y-tolerance, z-tolerance, x+tolerance, y+tolerance, z+tolerance)
             else:
                 points = [Vertex.Coordinates(v, mantissa=mantissa) for v in Topology.Vertices(topology)]
-            aabb_box = AABB.from_points(points, pad = tolerance)
+                aabb_box = AABB.from_points(points, pad = tolerance)
             return_topologies.extend([bvh.items[i] for i in BVH.QueryAABB(bvh, aabb_box)])
-        return return_topologies              
+        return return_topologies
 
     @staticmethod
     def Raycast(bvh, origin, direction: Tuple[float, float, float], mantissa: int = 6, silent: bool = False) -> List[int]:

topologicpy/Face.py

@@ -1933,7 +1933,12 @@ class Face():
             return centroid
 
         shell = Topology.Triangulate(face)
-        ib = Shell.InternalBoundaries(shell)
+        # ib = Shell.InternalEdges(shell)
+        # centroids = [Topology.Centroid(t) for t in ib]
+        faces = Topology.Faces(shell)
+        centroids = [Topology.Centroid(t) for t in faces]
+        cluster = Cluster.ByTopologies(centroids)
+        return Vertex.NearestVertex(centroid, cluster)
         cluster = Cluster.ByTopologies(ib)
         edges = Topology.Edges(cluster)
         bvh = BVH.ByTopologies(edges, tolerance=tolerance, silent=True)
@@ -3356,7 +3361,7 @@ class Face():
         return Face.Rectangle(origin=origin, width=width, length=length, direction = direction, placement=placement, tolerance=tolerance)
 
     @staticmethod
-    def Rectangle(origin= None, width: float = 1.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+    def Rectangle(origin= None, width: float = 1.0, length: float = 1.0, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001, silent: bool = True):
         """
         Creates a rectangle.
 
@@ -3374,6 +3379,8 @@ class Face():
             The description of the placement of the origin of the rectangle. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. Default is "center".
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
 
         Returns
         -------
@@ -3384,9 +3391,10 @@ class Face():
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
         
-        wire = Wire.Rectangle(origin=origin, width=width, length=length, direction=direction, placement=placement, tolerance=tolerance)
+        wire = Wire.Rectangle(origin=origin, width=width, length=length, direction=direction, placement=placement, tolerance=tolerance, silent=silent)
         if not Topology.IsInstance(wire, "Wire"):
-            print("Face.Rectangle - Error: Could not create the base wire for the rectangle. Returning None.")
+            if not silent:
+                print("Face.Rectangle - Error: Could not create the base wire for the rectangle. Returning None.")
             return None
         return Face.ByWire(wire, tolerance=tolerance)
     

topologicpy/Plotly.py

@@ -902,8 +902,22 @@ class Plotly:
                        faceLegendLabel="Topology Faces",
                        faceLegendRank=3,
                        faceLegendGroup=3, 
-                       intensityKey=None, intensities=[], colorScale="viridis",
-                       mantissa=6, tolerance=0.0001, silent=False):
+                       intensityKey=None,
+                       intensities=[],
+                       material = "plastic",
+                       materialKey=None,
+                       ambient = None,
+                       ambientKey=None,
+                       diffuse = None,
+                       diffuseKey=None,
+                       specular = None,
+                       specularKey=None,
+                       roughness = None,
+                       roughnessKey=None,
+                       colorScale="viridis",
+                       mantissa=6,
+                       tolerance=0.0001,
+                       silent=False):
         """
         Creates plotly face, edge, and vertex data.
 
@@ -1035,10 +1049,50 @@ class Plotly:
             The legend rank order of the faces of this topology. Default is 3.
         faceLegendGroup : int , optional
             The number of the face legend group to which the faces of this topology belong. Default is 3.
-        intensityKey: str, optional
+        intensityKey : str, optional
             If not None, the dictionary of each vertex is searched for the value associated with the intensity key. This value is then used to color-code the vertex based on the colorScale. Default is None.
         intensities : list , optional
             The list of intensities against which to index the intensity of the vertex. Default is [].
+        material : str , optional
+            The type of object material. Supported pre-built materials are:
+            Preset     Ambient  Diffuse  Specular  Roughness  Description
+            --------------------------------------------------------------
+            chalk        1.0      0.4       0.0        1.0     Very soft shading, low contrast
+            concrete     0.85     0.75      0.05       0.9     Highly matte, micro-rough surface, minimal specular reflection
+            eggshell     0.65     0.85      0.25       0.45    Slight sheen, soft highlights without gloss
+            glossy       0.5      0.9       0.6        0.1     Highly polished appearance
+            matte        0.9      0.7       0.0        1.0     Flat, non-reflective surfaces
+            metallic     0.3      0.8       0.9        0.2     Strong, sharp reflections
+            plastic      0.6      0.9       0.2        0.4     Soft highlights, good shape readability
+            Default is plastic.
+        materialKey : str , optional
+            The dictionary key under which the material string is stored. Default is None.
+        ambient : float , optional
+            Controls the strength of ambient light applied uniformly to the surface.
+            Higher values reduce shading contrast by increasing overall brightness.
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is 0.6.
+        ambientKey : str , optional
+            The dictionary key under which the ambient value (float) is stored. Default is None.
+        diffuse : float , optional
+            Controls the strength of diffuse (Lambertian) lighting based on the angle
+            between the light direction and the surface normal.
+            Higher values enhance shape perception through shading.
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is None.
+        diffuseKey : str , optional
+            The dictionary key under which the diffuse value (float) is stored. Default is None.
+        specular : float , optional
+            Controls the intensity of specular (mirror-like) highlights on the surface.
+            Higher values produce sharper and brighter highlights, giving a glossy appearance.
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is None.
+        specularKey : str , optional
+            The dictionary key under which the specular value (float) is stored. Default is None.
+        roughness : float , optional
+            Controls the spread of specular highlights on the surface.
+            Lower values result in sharp, concentrated highlights (smooth surfaces),
+            while higher values produce broader, softer highlights (rough surfaces).
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is None.
+        roughnessKey : str , optional
+            The dictionary key under which the roughness value (float) is stored. Default is None.
         colorScale : str , optional
             The desired type of plotly color scales to use (e.g. "Viridis", "Plasma"). Default is "Viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
         mantissa : int , optional
@@ -1061,12 +1115,29 @@ class Plotly:
         from topologicpy.Helper import Helper
         from time import time
         
+        materials = {
+            "chalk": {"ambient":1.0, "diffuse":0.4, "specular":0.0, "roughness":1.0},
+            "concrete": {"ambient":0.85, "diffuse":0.75, "specular":0.05, "roughness":0.9},
+            "eggshell": {"ambient":0.65, "diffuse":0.85, "specular":0.25, "roughness":0.45},
+            "glossy": {"ambient":0.5, "diffuse":0.9, "specular":0.6, "roughness":0.1},
+            "matte": {"ambient":0.9, "diffuse":0.7, "specular":0.0, "roughness":1.0},
+            "metallic": {"ambient":0.3, "diffuse":0.8, "specular":0.9, "roughness":0.2},
+            "plastic": {"ambient":0.6, "diffuse":0.9, "specular":0.2, "roughness":0.4}
+        }
         def closest_index(input_value, values):
             return int(min(range(len(values)), key=lambda i: abs(values[i] - input_value)))
 
 
-        def faceData(vertices, faces, dictionaries=None, color="#FAFAFA", colorKey=None,
-                     opacity=0.5, opacityKey=None, labelKey=None, groupKey=None,
+        def faceData(vertices, faces, dictionaries=None,
+                     color="#FAFAFA",
+                     colorKey=None,
+                     opacity=0.5,
+                     opacityKey=None,
+                     ambient=0.6,
+                     diffuse=0.9,
+                     specular=0.2,
+                     roughness=0.4,
+                     labelKey=None, groupKey=None,
                      minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Faces",
                      legendGroup=3, legendRank=3, showLegend=True, intensities=None, colorScale="viridis"):
             x = []
@@ -1163,9 +1234,8 @@ class Plotly:
                     hoverinfo = 'text',
                     text = labels,
                     hovertext = labels,
-                    flatshading = True,
                     showscale = False,
-                    lighting = {"facenormalsepsilon": 0},
+                    lighting=dict(ambient=ambient, diffuse=diffuse, specular=specular, roughness=roughness)
                 )
             return fData
 
@@ -1274,15 +1344,52 @@ class Plotly:
                     data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
         
         if showFaces and Topology.Type(topology) >= Topology.TypeID("Face"):
+            d = Topology.Dictionary(topology)
             if not faceColorKey == None:
-                d = Topology.Dictionary(topology)
                 faceColor = Dictionary.ValueAtKey(d, faceColorKey, faceColor)
             if not faceOpacityKey == None:
-                d = Topology.Dictionary(topology)
                 d_opacity = Dictionary.ValueAtKey(d, key=faceOpacityKey)
                 if not d_opacity == None:
                     if 0 <= d_opacity <= 1:
                         faceOpacity = d_opacity
+
+            if not materialKey == None:
+                d_material = Dictionary.ValueAtKey(d, key=materialKey)
+                if not d_material == None and isinstance(d_material, str):
+                    if material in list(materials.keys()):
+                        material = d_material
+            if not material == None and isinstance(material, str):
+                material = material.lower()
+            if not material in list(materials.keys()):
+                material = "plastic"
+            if not ambientKey == None:
+                d_ambient = Dictionary.ValueAtKey(d, key=ambientKey)
+                if not d_ambient == None:
+                    if 0 <= d_ambient <= 1:
+                        ambient = d_ambient
+            if not diffuseKey == None:
+                d_diffuse = Dictionary.ValueAtKey(d, key=diffuseKey)
+                if not d_diffuse == None:
+                    if 0 <= d_diffuse <= 1:
+                        diffuse = d_diffuse
+            if not specularKey == None:
+                d_specular = Dictionary.ValueAtKey(d, key=specularKey)
+                if not d_specular == None:
+                    if 0 <= d_specular <= 1:
+                        specular = d_specular
+            if not roughnessKey == None:
+                d_roughness = Dictionary.ValueAtKey(d, key=roughnessKey)
+                if not d_roughness == None:
+                    if 0 <= d_roughness <= 1:
+                        roughness = d_roughness
+            if ambient == None:
+                ambient = materials[material]['ambient']
+            if diffuse == None:
+                diffuse = materials[material]['diffuse']
+            if specular == None:
+                specular = materials[material]['specular']
+            if roughness == None:
+                roughness = materials[material]['roughness']
             if Topology.IsInstance(topology, "Face"):
                 tp_faces = [topology]
             else:
@@ -1305,7 +1412,9 @@ class Plotly:
                     vertices = geo['vertices']
                     faces = geo['faces']
                     if len(faces) > 0:
-                        data.append(faceData(vertices, faces, dictionaries=f_dictionaries, color=faceColor, colorKey=faceColorKey, opacity=faceOpacity, opacityKey=faceOpacityKey, labelKey=faceLabelKey, groupKey=faceGroupKey, minGroup=faceMinGroup, maxGroup=faceMaxGroup, groups=faceGroups, legendLabel=faceLegendLabel, legendGroup=faceLegendGroup, legendRank=faceLegendRank, showLegend=showFaceLegend, intensities=intensityList, colorScale=colorScale))
+                        data.append(faceData(vertices, faces, dictionaries=f_dictionaries, color=faceColor, colorKey=faceColorKey, opacity=faceOpacity, opacityKey=faceOpacityKey,
+                                             ambient=ambient, diffuse=diffuse, specular=specular, roughness=roughness,
+                                             labelKey=faceLabelKey, groupKey=faceGroupKey, minGroup=faceMinGroup, maxGroup=faceMaxGroup, groups=faceGroups, legendLabel=faceLegendLabel, legendGroup=faceLegendGroup, legendRank=faceLegendRank, showLegend=showFaceLegend, intensities=intensityList, colorScale=colorScale))
         return data
 
     @staticmethod

topologicpy/Topology.py

@@ -1476,7 +1476,7 @@ class Topology():
             if Topology.Type(topologyC) == Topology.TypeID("Vertex"):
                 sinkVertices = [topologyC]
             elif hidimC >= Topology.TypeID("Vertex"):
-                sinkVertices = Topology.Vertices(topologyC)
+                sinkVertices = Topology.Vertices(topologyC, silent=True)
             if len(sourceVertices) > 0 and len(sinkVertices) > 0:
                 _ = Topology.TransferDictionaries(sourceVertices, sinkVertices, tolerance=tolerance)
 
@@ -1561,7 +1561,7 @@ class Topology():
         from topologicpy.Dictionary import Dictionary
 
         def bb(topology):
-            vertices = Topology.Vertices(topology)
+            vertices = Topology.Vertices(topology, silent=True)
             x = []
             y = []
             z = []
@@ -3207,191 +3207,326 @@ class Topology():
 
     @staticmethod
     def ByOBJString(objString: str, mtlString: str = None,
-                    defaultColor: list = [255,255,255], defaultOpacity: float = 1.0,
+                    defaultColor=None, defaultOpacity: float = 1.0,
                     transposeAxes: bool = True, removeCoplanarFaces: bool = False,
                     selfMerge: bool = False,
-                    mantissa = 6, tolerance = 0.0001):
+                    mantissa: int = 6, tolerance: float = 0.0001):
         """
-        Imports a topology from  OBJ and MTL strings.
+        Imports a TopologicPy hierarchy from OBJ and optional MTL strings.
 
-        Parameters
-        ----------
-        objString : str
-            The string of the OBJ file.
-        mtlString : str , optional
-            The string of the MTL file. Default is None.
-        defaultColor : list , optional
-            The default color to use if none is specified in the string. Default is [255, 255, 255] (white).
-        defaultOpacity : float , optional
-            The default opacity to use if none is specified in the string. Default is 1.0 (fully opaque).
-        transposeAxes : bool , optional
-            If set to True the Z and Y axes are transposed. Otherwise, they are not. Default is True.
-        removeCoplanarFaces : bool , optional
-            If set to True, coplanar faces are merged. Default is True.
-        selfMerge : bool , optional
-            If set to True, the faces of the imported topologies will each be self-merged to create higher-dimensional objects. Otherwise, they remain a cluster of faces. Default is False.
-        mantissa : int , optional
-            The number of decimal places to round the result to. Default is 6.
-        tolerance : float , optional
-            The desired tolerance. Default is 0.0001
+        Supported OBJ primitives
+        ------------------------
+        - v   : vertices
+        - l   : polylines (edges-only / wire-only models)
+        - f   : faces (tri/quad/ngon; may be self-merged)
+
+        Grouping
+        --------
+        - g / o : groups/objects become separate returned topologies (one per group/object)
+
+        Materials
+        ---------
+        - usemtl + MTL Kd/d/Tr are used to set:
+            color   : [R,G,B] in 0..255
+            opacity : 0..1
 
         Returns
         -------
         list
-            The imported topologies.
-
+            One TopologicPy topology per OBJ group/object:
+            - If a group has faces: returns (best effort) a merged topology (or a Cluster of faces).
+            - Else if a group has polylines/edges: returns a Cluster of Wires/Edges.
+            - Else if a group has only points: returns a Cluster of Vertices.
+            - If mixed: returns a Cluster containing the appropriate mix.
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Wire import Wire
-        from topologicpy.Face import Face
-        from topologicpy.Shell import Shell
-        from topologicpy.Cell import Cell
         from topologicpy.Cluster import Cluster
-        from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
-        from topologicpy.Helper import Helper
+        from topologicpy.Topology import Topology
+
+        if defaultColor is None:
+            defaultColor = [255, 255, 255]
 
-        def load_materials(mtl_string):
+        # -----------------------------
+        # MTL parsing (robust)
+        # -----------------------------
+        def load_materials(mtl_string: str):
             materials = {}
             if not mtl_string:
                 return materials
-            current_material = None
-            lines = mtlString.split('\n')
-            for line in lines:
-                line = line.strip()
-                if line.startswith('#') or not line:
+
+            current = None
+            for raw in mtl_string.splitlines():
+                line = raw.strip()
+                if not line or line.startswith("#"):
                     continue
                 parts = line.split()
                 if not parts:
                     continue
-                if parts[0] == 'newmtl':
-                    current_material = parts[1]
-                    materials[current_material] = {}
-                elif current_material:
-                    if parts[0] == 'Kd':  # Diffuse color
-                        materials[current_material]['Kd'] = list(map(float, parts[1:4]))
-                    elif parts[0] == 'Ka':  # Ambient color
-                        materials[current_material]['Ka'] = list(map(float, parts[1:4]))
-                    elif parts[0] == 'Ks':  # Specular color
-                        materials[current_material]['Ks'] = list(map(float, parts[1:4]))
-                    elif parts[0] == 'Ns':  # Specular exponent
-                        materials[current_material]['Ns'] = float(parts[1])
-                    elif parts[0] == 'd':  # Transparency
-                        materials[current_material]['d'] = float(parts[1])
-                    elif parts[0] == 'map_Kd':  # Diffuse texture map
-                        materials[current_material]['map_Kd'] = parts[1]
-                    # Add more properties as needed
+
+                tag = parts[0]
+                if tag == "newmtl" and len(parts) > 1:
+                    current = parts[1]
+                    materials[current] = {}
+                elif current:
+                    if tag in ("Kd", "Ka", "Ks") and len(parts) >= 4:
+                        materials[current][tag] = list(map(float, parts[1:4]))
+                    elif tag == "Ns" and len(parts) >= 2:
+                        materials[current]["Ns"] = float(parts[1])
+                    elif tag in ("d", "Tr") and len(parts) >= 2:
+                        # d is opacity; Tr sometimes is transparency (inverse)
+                        val = float(parts[1])
+                        if tag == "Tr":
+                            val = 1.0 - val
+                        materials[current]["d"] = val
+                    elif tag == "map_Kd" and len(parts) >= 2:
+                        materials[current]["map_Kd"] = " ".join(parts[1:])  # allow spaces
             return materials
 
         materials = load_materials(mtlString)
-        vertices = []
-        textures = []
-        normals = []
-        groups = {}
-        current_group = None
+
+        def clamp01(x: float) -> float:
+            return max(0.0, min(1.0, x))
+
+        def material_to_color_opacity(mat_name):
+            color = defaultColor
+            opacity = defaultOpacity
+            if mat_name and mat_name in materials:
+                m = materials[mat_name]
+                if "Kd" in m and isinstance(m["Kd"], list) and len(m["Kd"]) >= 3:
+                    color = [int(round(clamp01(c) * 255.0, 0)) for c in m["Kd"][:3]]
+                if "d" in m:
+                    try:
+                        opacity = float(m["d"])
+                    except Exception:
+                        opacity = defaultOpacity
+            return color, opacity
+
+        # -----------------------------
+        # OBJ parsing
+        # -----------------------------
+        verts_xyz = []
+        groups = {}  # name -> {"faces":[(triplets,mat)], "lines":[(indices,mat)], "points":[(idx,mat)]}
+        current_group = "default"
         current_material = None
-        lines = objString.split('\n')
-        for line in lines:
-            line = line.strip()
-            if line.startswith('#'):
+
+        def ensure_group(name: str):
+            if not name:
+                name = "default"
+            if name not in groups:
+                groups[name] = {"faces": [], "lines": [], "points": []}
+            return name
+
+        def resolve_index(idx: int, n: int):
+            """
+            OBJ indices are 1-based; negative indices are relative to the end.
+            Returns a 0-based index or None.
+            """
+            if idx is None:
+                return None
+            if idx > 0:
+                z = idx - 1
+            else:
+                z = n + idx  # idx is negative
+            if z < 0 or z >= n:
+                return None
+            return z
+
+        for raw in objString.splitlines():
+            line = raw.strip()
+            if not line or line.startswith("#"):
                 continue
 
             parts = line.split()
             if not parts:
                 continue
 
-            if parts[0] == 'v':
-                vertex = list(map(float, parts[1:4]))
-                vertex = [round(coord, mantissa) for coord in vertex]
-                if transposeAxes == True:
-                    vertex = [vertex[0], -vertex[2], vertex[1]]
-                vertices.append(vertex)
-            elif parts[0] == 'vt':
-                texture = list(map(float, parts[1:3]))
-                textures.append(texture)
-            elif parts[0] == 'vn':
-                normal = list(map(float, parts[1:4]))
-                normals.append(normal)
-            elif parts[0] == 'f':
-                face = []
-                for part in parts[1:]:
-                    indices = part.split('/')
-                    vertex_index = int(indices[0]) - 1 if indices[0] else None
-                    texture_index = int(indices[1]) - 1 if len(indices) > 1 and indices[1] else None
-                    normal_index = int(indices[2]) - 1 if len(indices) > 2 and indices[2] else None
-                    face.append((vertex_index, texture_index, normal_index))
-
-                if current_group not in groups:
-                    groups[current_group] = []
-                groups[current_group].append((face, current_material))
-            elif parts[0] == 'usemtl':
+            tag = parts[0]
+
+            if tag == "v" and len(parts) >= 4:
+                v = list(map(float, parts[1:4]))
+                v = [round(c, mantissa) for c in v]
+                if transposeAxes:
+                    v = [v[0], -v[2], v[1]]
+                verts_xyz.append(v)
+
+            elif tag == "usemtl" and len(parts) >= 2:
                 current_material = parts[1]
-            elif parts[0] == 'g' or parts[0] == 'o':
-                current_group = ' '.join(parts[1:]) if len(parts) > 1 else None
-
-        obj_data = {
-            'vertices': vertices,
-            'textures': textures,
-            'normals': normals,
-            'materials': materials,
-            'groups': groups
-        }
-        print(obj_data.keys())
-        vertices = obj_data['vertices']
-        groups = obj_data['groups']
-        materials = obj_data['materials']
-        names = list(groups.keys())
-        return_topologies = []
-        for i in range(len(names)):
-            object_faces = []
-            face_selectors = []
-            object_name = names[i]
-            faces = groups[object_name]
-            print("Number of faces:", len(faces))
-            f = faces[0] # Get object material from first face. Assume it is the material of the group
-            object_color = defaultColor
-            object_opacity = defaultOpacity
-            object_material = None
-            if len(f) >= 2:
-                object_material = f[1]
-                if object_material in materials.keys():
-                    object_color = materials[object_material]['Kd']
-                    object_color = [int(round(c*255,0)) for c in object_color]
-                    object_opacity = materials[object_material]['d']
-            for f in faces:
-                indices = f[0]
-                face_material = f[1]
-                face_indices = []
-                for coordinate in indices:
-                    face_indices.append(coordinate[0])
-                face = Topology.ByGeometry(vertices=vertices, faces=[face_indices])
-                object_faces.append(face)
-                if not face_material == object_material:
-                    if face_material in materials.keys():
-                        face_color = materials[face_material]['Kd']
-                        face_color = [int(round(c*255,0)) for c in face_color]
-                        face_opacity = materials[face_material]['d']
-                        selector = Face.InternalVertex(face)
-                        d = Dictionary.ByKeysValues(['color', 'opacity'], [face_color, face_opacity])
-                        selector = Topology.SetDictionary(selector, d)
-                        face_selectors.append(selector)
-              
-            #topology = Cluster.ByTopologies(object_faces)
-        return object_faces
-        #     if Topology.IsInstance(topology, "Topology"):
-        #         if selfMerge:
-        #             topology = Topology.SelfMerge(topology)
-        #         if Topology.IsInstance(topology, "Topology"):
-        #             if removeCoplanarFaces:
-        #                 topology = Topology.RemoveCoplanarFaces(topology, tolerance=tolerance)
-        #             if Topology.IsInstance(topology, "Topology"):
-        #                 d = Dictionary.ByKeysValues(['name', 'color', 'opacity'], [object_name, object_color, object_opacity])
-        #                 topology = Topology.SetDictionary(topology, d)
-        #                 if len(face_selectors) > 0:
-        #                     topology = Topology.TransferDictionariesBySelectors(topology, selectors=face_selectors, tranFaces=True, tolerance=tolerance)
-        #                 return_topologies.append(topology)
-        # return return_topologies
+
+            elif tag in ("g", "o"):
+                name = " ".join(parts[1:]).strip() if len(parts) > 1 else "default"
+                current_group = ensure_group(name)
+
+            elif tag == "f" and len(parts) >= 4:
+                current_group = ensure_group(current_group)
+
+                triplets = []
+                for p in parts[1:]:
+                    toks = p.split("/")
+                    vi = int(toks[0]) if toks[0] else None
+                    vti = int(toks[1]) if len(toks) > 1 and toks[1] else None
+                    vni = int(toks[2]) if len(toks) > 2 and toks[2] else None
+
+                    vi = resolve_index(vi, len(verts_xyz))
+                    triplets.append((vi, vti, vni))
+
+                if any(t[0] is None for t in triplets):
+                    continue
+
+                groups[current_group]["faces"].append((triplets, current_material))
+
+            elif tag == "l" and len(parts) >= 3:
+                # OBJ "l": polyline defined by vertex indices, optionally with texture indices.
+                # We'll read only vertex indices (first number before any '/')
+                current_group = ensure_group(current_group)
+
+                idxs = []
+                ok = True
+                for token in parts[1:]:
+                    # token can be "v" or "v/vt"
+                    subtoks = token.split("/")
+                    if not subtoks or not subtoks[0]:
+                        ok = False
+                        break
+                    vi = resolve_index(int(subtoks[0]), len(verts_xyz))
+                    if vi is None:
+                        ok = False
+                        break
+                    idxs.append(vi)
+
+                if not ok or len(idxs) < 2:
+                    continue
+
+                groups[current_group]["lines"].append((idxs, current_material))
+
+            elif tag == "p" and len(parts) >= 2:
+                # OBJ "p": point list (rare). Keep as vertices.
+                current_group = ensure_group(current_group)
+                for token in parts[1:]:
+                    try:
+                        vi = resolve_index(int(token), len(verts_xyz))
+                    except Exception:
+                        vi = None
+                    if vi is not None:
+                        groups[current_group]["points"].append((vi, current_material))
+
+            else:
+                # ignore: vt, vn, s, mtllib, etc. (vt/vn are not needed for Topologic hierarchy here)
+                pass
+
+        # If OBJ never declared a group but had geometry, ensure "default" exists
+        if not groups:
+            ensure_group("default")
+
+        # -----------------------------
+        # Build Topologic hierarchy
+        # -----------------------------
+        def set_dict(topo, group_name: str, mat_name: str):
+            c, a = material_to_color_opacity(mat_name)
+            d = Dictionary.ByKeysValues(
+                ["name", "group", "material", "color", "opacity"],
+                [group_name, group_name, mat_name if mat_name else "", c, a]
+            )
+            return Topology.SetDictionary(topo, d)
+
+        imported = []
+
+        for group_name, rec in groups.items():
+            faces_rec = rec.get("faces", [])
+            lines_rec = rec.get("lines", [])
+            points_rec = rec.get("points", [])
+
+            topologies = []
+
+            # --- Faces
+            face_topos = []
+            for triplets, mat in faces_rec:
+                face_indices = [t[0] for t in triplets]
+                # Create a face from raw coordinates (Topology.ByGeometry expects vertices as coordinate lists)
+                topo_face = Topology.ByGeometry(vertices=verts_xyz, faces=[face_indices])
+                if topo_face is None:
+                    continue
+                topo_face = set_dict(topo_face, group_name, mat)
+                face_topos.append(topo_face)
+
+            if face_topos:
+                # If requested, attempt to merge coplanar faces / build higher-dimensional objects
+                face_cluster = Cluster.ByTopologies(face_topos)
+                face_cluster = set_dict(face_cluster, group_name, faces_rec[0][1] if faces_rec else None)
+
+                if selfMerge or removeCoplanarFaces:
+                    merged = Topology.SelfMerge(face_cluster, tolerance=tolerance)
+                    if merged is not None:
+                        face_cluster = merged
+                        # Keep group-level dict (SelfMerge may drop dictionaries)
+                        face_cluster = set_dict(face_cluster, group_name, faces_rec[0][1] if faces_rec else None)
+
+                topologies.append(face_cluster)
+
+            # --- Lines (Wires/Edges)
+            line_topos = []
+            for idxs, mat in lines_rec:
+                v_objs = [Vertex.ByCoordinates(*verts_xyz[i]) for i in idxs]
+                if len(v_objs) == 2:
+                    topo = Edge.ByVertices(v_objs[0], v_objs[1], tolerance=tolerance)
+                else:
+                    topo = Wire.ByVertices(v_objs, close=False, tolerance=tolerance)
+                if topo is None:
+                    continue
+                topo = set_dict(topo, group_name, mat)
+                line_topos.append(topo)
+
+            if line_topos:
+                line_cluster = Cluster.ByTopologies(line_topos)
+                line_cluster = set_dict(line_cluster, group_name, lines_rec[0][1] if lines_rec else None)
+                topologies.append(line_cluster)
+
+            # --- Points (Vertices)
+            point_topos = []
+            # If there are explicit "p" points, use them.
+            # If there is no geometry at all except vertices in the file and no p/l/f,
+            # we’ll fall back to all vertices later.
+            for vi, mat in points_rec:
+                v = Vertex.ByCoordinates(*verts_xyz[vi])
+                v = set_dict(v, group_name, mat)
+                point_topos.append(v)
+
+            if point_topos:
+                point_cluster = Cluster.ByTopologies(point_topos)
+                point_cluster = set_dict(point_cluster, group_name, points_rec[0][1] if points_rec else None)
+                topologies.append(point_cluster)
+
+            # --- If group had *no* faces/lines/points but there are vertices in the file, return all vertices
+            if not topologies and verts_xyz:
+                all_vs = [Vertex.ByCoordinates(*xyz) for xyz in verts_xyz]
+                v_cluster = Cluster.ByTopologies(all_vs)
+                v_cluster = set_dict(v_cluster, group_name, None)
+                topologies.append(v_cluster)
+
+            # --- Decide "correct hierarchy" output for this group
+            if not topologies:
+                continue
+            elif len(topologies) == 1:
+                group_topo = topologies[0]
+            else:
+                # Mixed geometry in same group: return a cluster containing the mixed subclusters
+                group_topo = Cluster.ByTopologies(topologies)
+                # Use first available material as group hint
+                hint_mat = None
+                if faces_rec:
+                    hint_mat = faces_rec[0][1]
+                elif lines_rec:
+                    hint_mat = lines_rec[0][1]
+                elif points_rec:
+                    hint_mat = points_rec[0][1]
+                group_topo = set_dict(group_topo, group_name, hint_mat)
+
+            imported.append(group_topo)
+
+        return imported
+
 
     @staticmethod
     def ByOCCTShape(occtShape):
@@ -4537,7 +4672,7 @@ class Topology():
             convex_hull = Topology.Unflatten(convex_hull_2, origin=centroid, direction=normal)
             return convex_hull
         
-        vertices = Topology.Vertices(topology)
+        vertices = Topology.Vertices(topology, silent=True)
         if len(vertices) < 3:
             if not silent:
                 print("Topology.ConvexHull - Error: Need at least 3 points to compute a convex hull.")
@@ -5723,7 +5858,7 @@ class Topology():
             topology = Topology.SelfMerge(topology, tolerance=tolerance)
             if Topology.TypeAsString(topology).lower() == "edge":
                 return topology
-            vertices = Topology.Vertices(topology)
+            vertices = Topology.Vertices(topology, silent=True)
             if len(vertices) < 2:
                 print("Topology.Fix - Error: Desired topologyType cannot be achieved. Returning original topology.")
                 return topology
@@ -5736,7 +5871,7 @@ class Topology():
             topology = Topology.SelfMerge(topology, tolerance=tolerance)
             if Topology.TypeAsString(topology).lower() == "vertex":
                 return topology
-            vertices = Topology.Vertices(topology)
+            vertices = Topology.Vertices(topology,silent=True)
             if len(vertices) < 1:
                 print("Topology.Fix - Error: Desired topologyType cannot be achieved. Returning original topology.")
                 return topology
@@ -6673,7 +6808,7 @@ class Topology():
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.IsPlanar - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
-        vertices = Topology.Vertices(topology)
+        vertices = Topology.Vertices(topology, silent=True)
 
         result = True
         if len(vertices) <= 3:
@@ -8493,7 +8628,7 @@ class Topology():
         vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
         if len(vertices) < 1:
             return topology
-        t_vertices = Topology.Vertices(topology)
+        t_vertices = Topology.Vertices(topology, silent=True)
         t_edges = Topology.Edges(topology)
         if len(t_vertices) < 1:
             return topology
@@ -9011,7 +9146,7 @@ class Topology():
         topFaces = Topology.Faces(topology)
         topWires = Topology.Wires(topology)
         topEdges = Topology.Edges(topology)
-        topVertices = Topology.Vertices(topology)
+        topVertices = Topology.Vertices(topology, silent=True)
         if len(topCC) == 1:
             cc = topCC[0]
             ccVertices = Topology.Vertices(cc)
@@ -9937,6 +10072,17 @@ class Topology():
              faceLegendLabel="Faces",
              intensityKey=None,
              intensities=[],
+
+             material = "plastic",
+             materialKey=None,
+             ambient = None,
+             ambientKey=None,
+             diffuse = None,
+             diffuseKey=None,
+             specular = None,
+             specularKey=None,
+             roughness = None,
+             roughnessKey=None,
              
              width=950,
              height=500,
@@ -10139,6 +10285,46 @@ class Topology():
             If not None, the dictionary of each vertex is searched for the value associated with the intensity key. This value is then used to color-code the vertex based on the colorScale. Default is None.
         intensities : list , optional
             The list of intensities against which to index the intensity of the vertex. Default is [].
+        material : str , optional
+            The type of object material. Case in-sensitive. Supported pre-built materials are:
+            Preset     Ambient  Diffuse  Specular  Roughness  Description
+            --------------------------------------------------------------
+            chalk        1.0      0.4       0.0        1.0     Very soft shading, low contrast
+            concrete     0.85     0.75      0.05       0.9     Highly matte, micro-rough surface, minimal specular reflection
+            eggshell     0.65     0.85      0.25       0.45    Slight sheen, soft highlights without gloss
+            glossy       0.5      0.9       0.6        0.1     Highly polished appearance
+            matte        0.9      0.7       0.0        1.0     Flat, non-reflective surfaces
+            metallic     0.3      0.8       0.9        0.2     Strong, sharp reflections
+            plastic      0.6      0.9       0.2        0.4     Soft highlights, good shape readability
+            Default is "plastic".
+        materialKey : str , optional
+            The dictionary key under which the material string is stored. Default is None.
+        ambient : float , optional
+            Controls the strength of ambient light applied uniformly to the surface.
+            Higher values reduce shading contrast by increasing overall brightness.
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is 0.6.
+        ambientKey : str , optional
+            The dictionary key under which the ambient value (float) is stored. Default is None.
+        diffuse : float , optional
+            Controls the strength of diffuse (Lambertian) lighting based on the angle
+            between the light direction and the surface normal.
+            Higher values enhance shape perception through shading.
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is None.
+        diffuseKey : str , optional
+            The dictionary key under which the diffuse value (float) is stored. Default is None.
+        specular : float , optional
+            Controls the intensity of specular (mirror-like) highlights on the surface.
+            Higher values produce sharper and brighter highlights, giving a glossy appearance.
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is None.
+        specularKey : str , optional
+            The dictionary key under which the specular value (float) is stored. Default is None.
+        roughness : float , optional
+            Controls the spread of specular highlights on the surface.
+            Lower values result in sharp, concentrated highlights (smooth surfaces),
+            while higher values produce broader, softer highlights (rough surfaces).
+            Typical range is [0, 1]. This over-rides the material pre-sets. Default is None.
+        roughnessKey : str , optional
+            The dictionary key under which the roughness value (float) is stored. Default is None.
         showScale : bool , optional
             If set to True, the colorbar is shown. Default is False.
         cbValues : list , optional
@@ -10333,6 +10519,16 @@ class Topology():
                                               faceLegendGroup=topology_counter+3,
                                               intensityKey=intensityKey,
                                               intensities=intensities,
+                                              material=material,
+                                              materialKey=materialKey,
+                                              ambient=ambient,
+                                              ambientKey=ambientKey,
+                                              diffuse=diffuse,
+                                              diffuseKey=diffuseKey,
+                                              specular=specular,
+                                              specularKey=specularKey,
+                                              roughness=roughness,
+                                              roughnessKey=roughnessKey,
                                               colorScale=colorScale,
                                               mantissa=mantissa,
                                               tolerance=tolerance,
@@ -11276,7 +11472,7 @@ class Topology():
             topology = Topology.Triangulate(topology)
         if not Topology.IsInstance(origin, "Vertex"):
             origin = Topology.Centroid(topology)
-        vertices = Topology.Vertices(topology)
+        vertices = Topology.Vertices(topology, silent=True)
         zList = [Vertex.Z(v, mantissa=mantissa) for v in vertices]
         z_min = min(zList)
         maxZ = max(zList)
@@ -11330,7 +11526,7 @@ class Topology():
         if not Topology.IsInstance(origin, "Vertex"):
             origin = Topology.Centroid(topology)
             
-        vertices = Topology.Vertices(topology)
+        vertices = Topology.Vertices(topology, silent=True)
         zList = [Vertex.Z(v, mantissa=mantissa) for v in vertices]
         z_min = min(zList)
         maxZ = max(zList)
@@ -11392,7 +11588,7 @@ class Topology():
         return unflat_topology
     
     @staticmethod
-    def Vertices(topology, silent: bool = False):
+    def Vertices(topology, silent: bool = True):
         """
         Returns the vertices of the input topology.
 
@@ -11694,6 +11890,8 @@ class Topology():
             The input topology with the dictionaries transferred to its subtopologies.
 
         """
+        import time
+        # timePrep = time.time()
         from topologicpy.Vertex import Vertex
         from topologicpy.Cluster import Cluster
         from topologicpy.Dictionary import Dictionary
@@ -11736,7 +11934,6 @@ class Topology():
                 return [topo]
             else:
                 return Topology.Vertices(topo, silent=True)
-
         vertices = []
         edges = []
         faces = []
@@ -11754,14 +11951,31 @@ class Topology():
         primitives.extend(faces)
         primitives.extend(edges)
         primitives.extend(vertices)
-        cluster = Cluster.ByTopologies(primitives)
+        # print("bvh preparation", f"{time.time() - timePrep:.4f}s", len(primitives))
+
+        # timeStart = time.time()
+
+        bvh = BVH.ByTopologies(primitives, tolerance=tolerance, silent=True)
+        # print("bvh created", f"{time.time() - timeStart:.4f}s", len(bvh.items))
+
         for s in selectors:
-            status, element = Vertex.IsInternal(s, cluster, identify=True, tolerance=tolerance)
-            if status:
-                d1 = Topology.Dictionary(s)
-                d2 = Topology.Dictionary(element)
-                d3 = Dictionary.ByMergedDictionaries(d1, d2)
-                element = Topology.SetDictionary(element, d3)
+            try:
+                candidates = BVH.Clashes(bvh, s, tolerance=tolerance) or []
+            except Exception as e:
+                # print(f"BVH clash query failed for a selector. Trying fallback. {e}")
+                # Fallback if your BVH needs a non-degenerate query
+                candidates = primitives
+
+            if not candidates:
+                continue
+            for element in candidates:
+                status = Vertex.IsInternal(s, element, tolerance=tolerance)
+                if status:
+                    d1 = Topology.Dictionary(s)
+                    d2 = Topology.Dictionary(element)
+                    d3 = Dictionary.ByMergedDictionaries(d1, d2)
+                    element = Topology.SetDictionary(element, d3)
+        # print("bvh query done", f"{time.time() - timeStart:.4f}s")
         return topology
 
     @staticmethod
@@ -11885,7 +12099,7 @@ class Topology():
                                                  silent=silent)
         
         if transferDictionaries == True:
-            vertices = Topology.Vertices(topology)
+            vertices = Topology.Vertices(topology, silent=True)
             edges = Topology.Edges(topology, silent=True)
             wires = Topology.Wires(topology, silent=True)
             faces = Topology.Faces(topology, silent=True)

topologicpy/Vertex.py

@@ -1293,7 +1293,13 @@ class Vertex():
         # --------------------------
         points = [Vertex.Coordinates(v) for v in Topology.Vertices(topology)]
         aabb = AABB.from_points(points, pad=tolerance)
+        if(Vertex.Coordinates(vertex) is None): 
+            if identify:
+                return (False, None)
+            return False
         if not aabb.contains_point(Vertex.Coordinates(vertex)):
+            if identify:
+                return (False, None)
             return False
 
         # --------------------------
@@ -1333,6 +1339,8 @@ class Vertex():
             edges = [] if faces or cells else collect_edges(topology)
             vertices = [] if edges or faces or cells else collect_vertices(topology)
         if not cells and not faces and not edges and not vertices:
+            if identify:
+                return (False, None)
             return False
 
         # --------------------------
@@ -1345,12 +1353,14 @@ class Vertex():
         primitives.extend(cells)
         bvh = BVH.ByTopologies(primitives, maxLeafSize=maxLeafSize, tolerance=tolerance, silent=True)
         try:
-            candidates = BVH.Clashes(bvh, vertex, tolernace=tolerance) or []
+            candidates = BVH.Clashes(bvh, vertex, tolerance=tolerance) or []
         except Exception:
             # Fallback if your BVH needs a non-degenerate query
             candidates = primitives
 
         if not candidates:
+            if identify:
+                return (False, None)
             return False
 
         # sort by types so that priority is given to lower dimensional types (e.g. vertices, then edges, then faces, then cells)
@@ -2313,6 +2323,29 @@ class Vertex():
         coords = [round(v, mantissa) for v in coords]
         return Vertex.ByCoordinates(coords)
     
+    @staticmethod
+    def Weld(vertices: list, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Returns a list of vertices where vertices within a specified tolerance distance are fused while retaining duplicates, ensuring that vertices with nearly identical coordinates are replaced by a single shared coordinate.
+
+        Parameters
+        ----------
+        vertices : list
+            The input list of topologic vertices.
+        mantissa : int , optional
+            The desired length of the mantissa for retrieving vertex coordinates. Default is 6.
+        tolerance : float , optional
+            The desired tolerance for computing if vertices need to be fused. Any vertices that are closer to each other than this tolerance will be fused. Default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of fused vertices. This list contains the same number of vertices and in the same order as the input list of vertices. However, the coordinates
+            of these vertices have now been modified so that they are exactly the same with other vertices that are within the tolerance distance.
+        
+        """
+        return Vertex.Fuse(vertices = vertices, mantissa = mantissa, tolerance = tolerance)
+    
     @staticmethod
     def X(vertex, mantissa: int = 6) -> float:
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.97'
+__version__ = '0.8.98'

{topologicpy-0.8.97.dist-info → topologicpy-0.8.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.97
+Version: 0.8.98
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.8.97.dist-info → topologicpy-0.8.98.dist-info}/RECORD

@@ -1,6 +1,6 @@
 topologicpy/ANN.py,sha256=gpflv4lFypOW789vO7mSkMLaMF_ZftVOCqCvtGr6-JA,47873
 topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
-topologicpy/BVH.py,sha256=ts0Ru24ILjjfHa54SYNhMc8Jkyxwej1DV0Jv7P_6BoU,22513
+topologicpy/BVH.py,sha256=cdRld28xxZgKbY-k45WN4PKzLRGCf9XSrFOGYIvPG2o,22615
 topologicpy/CSG.py,sha256=09la1-xzS9vr-WnV7tpJ0I-mkZ-XY0MRSd5iB50Nfgw,15556
 topologicpy/Cell.py,sha256=CuJogHS7N7svEKbEazYrYyOhLBb38vlF2Xkwqg3mS3w,201692
 topologicpy/CellComplex.py,sha256=B8bAW6M5fClfXb9nSLDhrgtNRlU888Z4EcUzBZtBqss,68558
@@ -11,7 +11,7 @@ topologicpy/DGL.py,sha256=O7r22ss0tgak4kWaACkyExhR_rZ46O_bqIBpxAcwJkw,138918
 topologicpy/Dictionary.py,sha256=3QRxvobXxaCb7TVeiNgG3Ka3R_1Hmco-njZCVjKNQBM,78073
 topologicpy/Edge.py,sha256=m_ThzU748H-vySQHx15VBIQCekWBbbISns29cnbEGfs,77593
 topologicpy/EnergyModel.py,sha256=MEai1GF1hINeH5bhclJj_lpMU3asFTvW2RlPm40GNj4,57794
-topologicpy/Face.py,sha256=B1w9D0vqbEllyI_N6XlS0cjS7Cysoa-wC_df4DsmvNE,203233
+topologicpy/Face.py,sha256=XEs6cSDBLzhRQLtNydIOJVLCvetkR6E4HE7KVeqhngE,203677
 topologicpy/Graph.py,sha256=7C9Cw3-0L9IqKsCTscHIo9luKoC-80s_-xXDxsBn95w,868150
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
 topologicpy/Helper.py,sha256=NsmMlbbKFPRX6jfoko-ZQVQ7MBsfVp9FD0ZvC2U7q-8,32002
@@ -19,21 +19,21 @@ topologicpy/Honeybee.py,sha256=dBk01jIvxjQMGHqSarM1Cukv16ot4Op7Dwlitn2OMoc,48990
 topologicpy/Kuzu.py,sha256=fxaDPWM5Xam7Tot0olPZsazS_7xgE_Vo-jf0Sbv3VZE,36298
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
-topologicpy/Plotly.py,sha256=Uy-UKFfJ408Vc0rcWD_lWiz5QAYjTNMtvDjWXMWIDQk,123088
+topologicpy/Plotly.py,sha256=NqTdQYOnc2WLx13-vIZnumPzPD5IReQmj43pmBhufx4,129402
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=wOsoBFxMgwZYWjj86OMkz_PJuQ02locV_djhSDD6dVc,109644
 topologicpy/ShapeGrammar.py,sha256=q_BvMKOBDW3GVSRjPLIGAZkHW2egw3mTOPzIyEpYOLg,23349
 topologicpy/Shell.py,sha256=2EPzDT_t0IAjBRYPDuKNAz_Ax_HaEkvNpXBxDkPdcTg,101084
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=ezisiHfc2nd7A_8w0Ykq2VgbS0A9WNSg-tBwvfTQAVM,36735
-topologicpy/Topology.py,sha256=Kj3jzEQZLtlF-OWclcEGWxn61bRaNheaHKvRwJfOjb0,565597
+topologicpy/Topology.py,sha256=DZ1C7lhaEq-gORVkFuttd117SsFGWbjGyAINH3Ityi4,574696
 topologicpy/Vector.py,sha256=9COmLAEo3GSDntVFWligGFKJbEqUTSGmDWQDxpvfR-M,47485
-topologicpy/Vertex.py,sha256=U27XJ4Cst9KbzVzIi9p_EStfORHVp9cPaDJbJW7NnxQ,98021
+topologicpy/Vertex.py,sha256=tO8A6du8AuqObSaKcdg6rf4096sfBQ3ZZ9yRNuOt_NU,99607
 topologicpy/Wire.py,sha256=3TkcBmkfGIL8Heffwnc1DQtkKyFG3qvV-kJ-lvXXB0g,273765
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=xkAWU_wH3G7m4Ee1I6N049xSQRkjPtyviSda_8D2UHA,23
-topologicpy-0.8.97.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.97.dist-info/METADATA,sha256=Wt9YA9TiW8yHxJoQDEjcv2uS2SXHTCMXnPUzs6zHMhY,10535
-topologicpy-0.8.97.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-topologicpy-0.8.97.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.97.dist-info/RECORD,,
+topologicpy/version.py,sha256=7BBu0vOw-A-OJaqnGWj1psRzl_NVgYN_GFKu2htJik4,23
+topologicpy-0.8.98.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.98.dist-info/METADATA,sha256=eObpiO-eV-0F-eooxd1qylFZ5cW2S7l9vVyb6HX-Too,10535
+topologicpy-0.8.98.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+topologicpy-0.8.98.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.98.dist-info/RECORD,,

{topologicpy-0.8.97.dist-info → topologicpy-0.8.98.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any