topologicpy 0.7.76__py3-none-any.whl → 0.7.78__py3-none-any.whl

topologicpy/Face.py

@@ -1281,7 +1281,7 @@ class Face():
         return return_list
 
     @staticmethod
-    def ExternalBoundary(face):
+    def ExternalBoundary(face, silent=False):
         """
         Returns the external boundary (closed wire) of the input face.
 
@@ -1289,6 +1289,8 @@ class Face():
         ----------
         face : topologic_core.Face
             The input face.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1300,6 +1302,10 @@ class Face():
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
+        if not Topology.IsInstance(face, "face"):
+            if not silent:
+                print("Face.ExternalBoundary - Error: The input face parameter is not a topologic face. Returning None.")
+            return None
         eb = face.ExternalBoundary() # Hook to Core
         return eb
     

topologicpy/Graph.py

@@ -1880,9 +1880,9 @@ class Graph:
         else:
             node_keys = [nodeIDHeader, nodeLabelHeader, "mask"]+nodeFeaturesKeys
         if len(edgeFeaturesKeys) == 0:
-            edge_keys = [edgeLabelHeader, "mask", edgeFeaturesHeader]
+            edge_keys = [edgeSRCHeader, edgeDSTHeader, edgeLabelHeader, "mask", edgeFeaturesHeader]
         else:
-            edge_keys = [edgeLabelHeader, "mask"]+edgeFeaturesKeys
+            edge_keys = [edgeSRCHeader, edgeDSTHeader, edgeLabelHeader, "mask"]+edgeFeaturesKeys
         if len(graphFeaturesKeys) == 0:
             graph_keys = [graphIDHeader, graphLabelHeader, graphFeaturesHeader]
         else:
@@ -1975,11 +1975,11 @@ class Graph:
                     mask = 0
                 features = row[edgeFeaturesHeader]
                 if len(edgeFeaturesKeys) == 0:
-                    values = [label, mask, features]
+                    values = [src_id, dst_id, label, mask, features]
                 else:
                     featureList = features.split(",")
                     featureList = [float(s) for s in featureList]
-                    values = [label, mask]+featureList
+                    values = [src_id, dst_id, label, mask]+featureList
                 if not (src_id == dst_id) and not [src_id, dst_id] in es and not [dst_id, src_id] in es:
                     es.append([src_id, dst_id])
                     try:

topologicpy/Plotly.py

@@ -474,9 +474,9 @@ class Plotly:
         x = []
         y = []
         z = []
-        sizeList = []
+        sizes = []
         labels = []
-        groupList = []
+        colors = []
         label = ""
         group = None
         if colorKey or sizeKey or labelKey or groupKey:
@@ -493,58 +493,54 @@ class Plotly:
             else:
                 minGroup = 0
                 maxGroup = 1
+            n = len(str(len(vertices)))
             for m, v in enumerate(vertices):
                 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)
                 if len(dictionaries) > 0:
                     d = dictionaries[m]
                     if d:
                         if not colorKey == None:
-                            d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
-                            color = Color.AnyToHex(d_color)
-                            groupList.append(color)
+                            colors[m] = Dictionary.ValueAtKey(d, key=colorKey) or colors[m]
                         if not labelKey == None:
-                            label = str(Dictionary.ValueAtKey(d, key=labelKey)) or " "
+                            labels[m] = str(Dictionary.ValueAtKey(d, key=labelKey)) or labels[m]
                         if not sizeKey == None:
-                            size = Dictionary.ValueAtKey(d, key=sizeKey) or size
+                            sizes[m] = Dictionary.ValueAtKey(d, key=sizeKey) or sizes[m]
                         if not groupKey == None:
-                            group = Dictionary.ValueAtKey(d, key=groupKey) or " "
+                            colors[m] = Dictionary.ValueAtKey(d, key=groupKey) or colors[m]
                     try:
-                        if group == " ":
-                            pass
-                        elif type(group) == int or type(group) == float:
-                            if group < minGroup:
-                                group = minGroup
-                            if group > maxGroup:
-                                group = maxGroup
-                            color = Color.ByValueInRange(group, minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                            color = Color.AnyToHEX(color)
-                            groupList.append(Color.AnyToHex(color))
+                        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:
-                            color = Color.ByValueInRange(groups.index(group), minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                            color = Color.AnyToHex(color)
-                            groupList.append(Color.AnyToHex(color))
+                            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
-                    labels.append(label)
-                    sizeList.append(size)
         else:
             for v in vertices:
                 x.append(v[0])
                 y.append(v[1])
                 z.append(v[2])
         
-        if len(list(set(groupList))) < 2:
-            groupList = Color.AnyToHex(color)
+        if len(list(set(colors))) < 2:
+            colors = Color.AnyToHex(color)
         if len(labels) < 1:
-            labels = ""
-        if len(sizeList) < 1:
-            sizeList = size
+            labels = "Vertex_1"
+        if len(sizes) < 1:
+            sizes = size
         if showVertexLabel == True:
             mode = "markers+text"
         else:
@@ -554,7 +550,9 @@ class Plotly:
                             z=z,
                             name=legendLabel,
                             showlegend=showLegend,
-                            marker=dict(color=groupList,  size=sizeList, opacity=1),
+                            marker=dict(color=colors,
+                                        size=sizes, 
+                                        opacity=1),
                             mode=mode,
                             legendgroup=legendGroup,
                             legendrank=legendRank,
@@ -601,13 +599,17 @@ class Plotly:
         else:
             minGroup = 0
             maxGroup = 1
+        
 
         if colorKey or widthKey or labelKey or groupKey:
             keys = [x for x in [colorKey, widthKey, labelKey, groupKey] if not x == None]
             temp_dict = Helper.ClusterByKeys(edges, dictionaries, keys, silent=False)
             dict_clusters = temp_dict["dictionaries"]
             elements_clusters = temp_dict['elements']
+            n = len(str(len(elements_clusters)))
+            labels = []
             for j, elements_cluster in enumerate(elements_clusters):
+                labels.append("Edge_"+str(j+1).zfill(n))
                 d = dict_clusters[j][0] # All dicitonaries have same values in dictionaries, so take first one.
                 if d:
                     if not colorKey == None:
@@ -616,7 +618,9 @@ class Plotly:
                     if not labelKey == None:
                         label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
                     if not widthKey == None:
-                        width = Dictionary.ValueAtKey(d, key=widthKey) or width
+                        e_width = Dictionary.ValueAtKey(d, key=widthKey)
+                        if not e_width == None:
+                            width = e_width
                     if not groupKey == None:
                         group = Dictionary.ValueAtKey(d, key=groupKey)
                         if not group == None:
@@ -629,6 +633,7 @@ class Plotly:
                             else:
                                 d_color = Color.ByValueInRange(groups.index(group), minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
                             color = d_color
+
                 x = []
                 y = []
                 z = []
@@ -639,15 +644,19 @@ class Plotly:
                     y+=[sv[1], ev[1], None] # y-coordinates of edge ends
                     z+=[sv[2], ev[2], None] # z-coordinates of edge ends
                 if showEdgeLabel == True:
-                    mode = "lines+text"
+                    mode = "markers+lines+text"
+                else:
+                    mode = "markers+lines"
+                if isinstance(width, list):
+                    marker_width = width[0]*0.25
                 else:
-                    mode = "lines"
+                    marker_width = width*0.25
                 trace = go.Scatter3d(x=x,
                                     y=y,
                                     z=z,
                                     name=label,
                                     showlegend=showLegend,
-                                    marker_size=0,
+                                    marker=dict(symbol="circle", size=marker_width),
                                     mode=mode,
                                     line=dict(color=color, width=width),
                                     legendgroup=legendGroup,
@@ -869,9 +878,9 @@ class Plotly:
             k = []
             labels = []
             groupList = []
-            faceColorList = []
             label = ""
             group = ""
+            color = Color.AnyToHex(color)
             if colorKey or labelKey or groupKey:
                 if groups:
                     if len(groups) > 0:
@@ -886,36 +895,40 @@ class Plotly:
                 else:
                     minGroup = 0
                     maxGroup = 1
+                n = len(str(len(faces)))
                 for m, f in enumerate(faces):
                     i.append(f[0])
                     j.append(f[1])
                     k.append(f[2])
                     label = ""
                     group = None
+                    groupList.append(Color.AnyToHex(color)) # Store a default color for that face
+                    labels.append("Mace_"+str(m+1).zfill(n))
                     if len(dictionaries) > 0:
                         d = dictionaries[m]
                         if d:
+                            if not colorKey == None:
+                                d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
+                                groupList[m] = Color.AnyToHex(d_color) #Replace the default color by the dictionary color.
                             if not labelKey == None:
-                                label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
+                                label = Dictionary.ValueAtKey(d, key=labelKey)
+                                if not label == None:
+                                    labels[m] = str(label) # Replace the default label with the dictionary label
                             if not groupKey == None:
                                 group = Dictionary.ValueAtKey(d, key=groupKey) or None
                         
                         if group == None:
-                            f_color = Color.AnyToHex(color)
-                            groupList.append(f_color)
+                            pass # do nothing because the default color will be used.
                         elif type(group) == int or type(group) == float:
                             if group < minGroup:
                                 group = minGroup
                             if group > maxGroup:
                                 group = maxGroup
                             f_color = Color.ByValueInRange(group, minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                            f_color = Color.AnyToHex(f_color)
-                            groupList.append(f_color)
+                            groupList[m] = Color.AnyToHex(f_color) # Replace the default color by the group value.
                         else:
                             f_color = Color.ByValueInRange(groups.index(group), minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                            f_color = Color.AnyToHex(f_color)
-                            groupList.append(f_color)
-                        labels.append(label)
+                            groupList[m] = Color.AnyToHex(f_color)
             else:
                 for f in faces:
                     i.append(f[0])
@@ -926,7 +939,6 @@ class Plotly:
                 groupList = None
             if len(labels) < 1:
                 labels = ""
-            color = Color.AnyToHex(color)
             fData = go.Mesh3d(
                     x = x,
                     y = y,
@@ -1030,6 +1042,7 @@ class Plotly:
                 if edgeColorKey or edgeWidthKey or edgeLabelKey or edgeGroupKey:
                     for tp_edge in tp_edges:
                         e_dictionaries.append(Topology.Dictionary(tp_edge))
+                        
                 e_cluster = Cluster.ByTopologies(tp_edges)
                 geo = Topology.Geometry(e_cluster, mantissa=mantissa)
                 vertices = geo['vertices']

topologicpy/Topology.py

@@ -1509,7 +1509,9 @@ class Topology():
         faces : list , optional
             The input list of faces in the form of [i, j, k, l, ...] where the items in the list are vertex indices. The face is assumed to be closed to the last vertex is connected to the first vertex automatically.
         topologyType : str , optional
-            The desired topology type. The options are: "Vertex", "Edge", "Wire", "Face", "Shell", "Cell", "CellComplex". If set to None, a "Cluster" will be returned. The default is None.
+            The desired highest topology type. The options are: "Vertex", "Edge", "Wire", "Face", "Shell", "Cell", "CellComplex".
+            It is case insensitive. If any of these options are selected, the returned topology will only contain this type either a single topology
+            or as a Cluster of these types of topologies. If set to None, a "Cluster" will be returned of vertices, edges, and/or faces. The default is None.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -1555,7 +1557,7 @@ class Topology():
                 output = Shell.ByFaces(faces, tolerance=tolerance)  # This can return a list
                 if Topology.IsInstance(output, "Shell"):
                     return output
-            elif topologyType == None:
+            elif topologyType == None or topologyType== "face":
                 output = Cluster.ByTopologies(faces)
 
             return output
@@ -1587,15 +1589,20 @@ class Topology():
             topologyType = topologyType.lower()
 
         if topologyType == "vertex":
-            if len(topVerts) >= 1:
+            if len(topVerts) == 0:
+                return None
+            if len(topVerts) == 1:
                 return topVerts[0]
             else:
-                return None
+                return Cluster.ByTopologies(topVerts)
         elif topologyType == "edge":
-            if len(edges) >= 1 and len(vertices) >= 2:
+            if len(edges) == 0:
+                return None
+            if len(edges) == 1 and len(vertices) >= 2:
                 return Edge.ByVertices(topVerts[edges[0][0]], topVerts[edges[0][1]], tolerance=tolerance)
             else:
-                return None
+                topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
+                return Cluster.ByTopologies(topEdges)
 
         if topologyType == "wire" and edges:
             topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
@@ -2160,12 +2167,13 @@ class Topology():
             for key in keys:
                 if python_dict[key].__class__ == ezdxf.acc.vector.Vec3:
                     python_dict[key] = list(python_dict[key])
+            rgb_list = None
             try:
-                r,g,b = entity.rgb
+                rgb_list = entity.rgb   
             except:
                 rgb_list = get_layer_color(file.layers, entity.dxf.layer)
-                if rgb_list == None:
-                    rgb_list = [0,0,0]
+            if rgb_list == None:
+                rgb_list = [0,0,0]
             python_dict['color'] = rgb_list
             python_dict['type'] = entity_type
             d = Dictionary.ByPythonDictionary(python_dict)
@@ -3634,6 +3642,325 @@ class Topology():
         """
         return topologic.Topology.ByOcctShape(occtShape, "")
     
+    @staticmethod
+    def ByPDFFile(file, wires=False, faces=False, includeTypes=[], excludeTypes=[], edgeColorKey="edge_color", edgeWidthKey="edge_width", faceColorKey="face_color", faceOpacityKey="face_opacity", tolerance=0.0001, silent=False):
+        """
+        Import PDF file and convert its entities to topologies.
+
+        Parameters
+        ----------
+        file : file
+            The input PDF file
+        wires : bool , optional
+            If set to True, wires will be constructed when possible. The default is True.
+        faces : bool , optional
+            If set to True, faces will be constructed when possible. The default is True.
+        includeTypes : list , optional
+            A list of PDF object types to include in the returned result. The default is [] which means all PDF objects will be included.
+            The possible strings to include in this list are: ["line", "curve", "rectangle", "quadrilateral"]
+        excludeTypes : list , optional
+            A list of PDF object types to exclude from the returned result. The default is [] which mean no PDF object type will be excluded.
+            The possible strings to include in this list are: ["line", "curve", "rectangle", "quadrilateral"]
+        edgeColorKey : str , optional
+            The dictionary key under which to store the edge color. The default is None.
+        edgeWidthKey : str , optional
+            The dictionary key under which to store the edge width. The default is None.
+        faceColorKey : str , optional
+            The dictionary key under which to store the face color. The default is None.
+        faceOpacityKey : str , optional
+            The dictionary key under which to store the face opacity. The default is None.
+        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
+        -------
+        list
+        A list of Topologic entities (edges, wires, faces, clusters) with attached dictionaries.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Dictionary import Dictionary
+        import os
+        import warnings
+
+        def interpolate_bezier(control_points, num_points=50):
+            """
+            Interpolate a cubic Bezier curve given control points.
+
+            Args:
+                control_points (list): List of control points (pymupdf.Point objects).
+                num_points (int): Number of points to interpolate along the curve.
+
+            Returns:
+                list: A list of interpolated points (pymupdf.Point objects).
+            """
+            p0, p1, p2, p3 = control_points
+            points = [
+                pymupdf.Point(
+                    (1 - t)**3 * p0.x + 3 * (1 - t)**2 * t * p1.x + 3 * (1 - t) * t**2 * p2.x + t**3 * p3.x,
+                    (1 - t)**3 * p0.y + 3 * (1 - t)**2 * t * p1.y + 3 * (1 - t) * t**2 * p2.y + t**3 * p3.y
+                )
+                for t in (i / num_points for i in range(num_points + 1))
+            ]
+            return points
+
+        def map_types(type_list):
+            type_mapping = {
+                "line": "l",
+                "curve": "c",
+                "rect": "re",
+                "quad": "qu"
+            }
+            return [type_mapping[key] for key in type_mapping if any(key in item for item in type_list)]
+
+        def remove_overlap(list1, list2):
+            set1, set2 = set(list1), set(list2)
+            # Remove common elements from both sets
+            set1 -= set2
+            set2 -= set(list1)
+            return list(set1), list(set2)
+        
+        try:
+            import pymupdf  # PyMuPDF
+        except:
+            if not silent:
+                print("Topology.ByPDFFile - Warning: Installing required PyMuPDF library.")
+            try:
+                os.system("pip install PyMuPDF")
+            except:
+                os.system("pip install PyMuPDF --user")
+            try:
+                import pymupdf
+                if not silent:
+                    print("Topology.ByPDFFile - Information: PyMUDF library installed correctly.")
+            except:
+                if not silent:
+                    warnings.warn("Topology.ByPDFFile - Error: Could not import PyMuPDF. Please try to install PyMuPDF manually. Returning None.")
+                return None
+        if not file:
+            if not silent:
+                print("Topology.ByPDFFile - Error: Could not open the PDF file. Returning None.")
+            return None
+        
+        if includeTypes == None:
+            includeTypes = []
+        if excludeTypes == None:
+            excludeTypes = []
+        includeTypes = [item for item in includeTypes if isinstance(item, str)]
+        excludeTypes = [item for item in excludeTypes if isinstance(item, str)]
+        in_types = map_types([c.lower() for c in includeTypes])
+        ex_types = map_types([c.lower() for c in excludeTypes])
+        in_types_1, ex_types_1 = remove_overlap(in_types, ex_types)
+        if not len(in_types_1) == len(in_types) or not len(ex_types_1) == len(ex_types):
+            if not silent:
+                print("Topology.ByPDFFile - Warning: Ther includeTypes and excludeTypes input parameters contain overlapping elements. These have been excluded.")
+        in_types = in_types_1
+
+        topologic_entities = []
+        for page_num, page in enumerate(file, 1):
+            matrix = pymupdf.Matrix(1, 1)  # Identity matrix for default transformation
+            paths = page.get_drawings()
+            for path in paths:
+                if not path.get("stroke_opacity") == 0:
+                    close = path.get("closePath")
+                    components = []
+                    edge_color = path.get("color", [0, 0, 0]) or [0, 0, 0]
+                    edge_color = [int(255 * c) for c in edge_color] # Convert stroke color to 0-255 range
+                    edge_width = path.get("width", 1) or 1
+                    face_color = path.get("fill", [1, 1, 1]) or [1,1,1]
+                    face_color = [int(255 * c) for c in face_color]
+                    face_opacity = path.get("fill_opacity", 1) or 1
+
+                    # Create the dictionary for line width, color, fill color, and fill opacity
+                    keys = [edgeWidthKey, edgeColorKey, faceColorKey, faceOpacityKey]
+                    values = [
+                        edge_width,
+                        edge_color,  # Convert stroke color to 0-255 range
+                        face_color,     # Convert fill color to 0-255 range
+                        face_opacity
+                    ]
+                    dictionary = Dictionary.ByKeysValues(keys, values)
+                    items = path.get("items") or []
+                    for it, item in enumerate(items):
+                        if (item[0] in in_types or len(in_types) == 0) and (not item[0] in ex_types):
+                            if item[0] == "l":  # Line
+                                start_point = pymupdf.Point(item[1][0], item[1][1]).transform(matrix)
+                                end_point = pymupdf.Point(item[2][0], item[2][1]).transform(matrix)
+                                start_vertex = Vertex.ByCoordinates(start_point.x, -start_point.y, 0)
+                                end_vertex = Vertex.ByCoordinates(end_point.x, -end_point.y, 0)
+                                d = Vertex.Distance(start_vertex, end_vertex)
+                                if d > tolerance:
+                                    edge = Edge.ByStartVertexEndVertex(start_vertex, end_vertex, tolerance=tolerance, silent=silent)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+                                if it == 0:
+                                    v_f_p = pymupdf.Point(item[1][0], item[1][1]).transform(matrix)
+                                    very_first_vertex = Vertex.ByCoordinates(v_f_p.x, -v_f_p.y, 0)
+                                if it == len(items)-1 and path.get("closePath", False) == True:
+                                    v_l_p = pymupdf.Point(item[2][0], item[2][1]).transform(matrix)
+                                    very_last_vertex = Vertex.ByCoordinates(v_l_p.x, -v_l_p.y, 0)
+                                    edge = Edge.ByStartVertexEndVertex(very_last_vertex, very_first_vertex, tolerance=tolerance, silent=True)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+                                
+                            elif item[0] == "c":  # Bezier curve (approximated by segments)
+                                control_points = [pymupdf.Point(p[0], p[1]).transform(matrix) for p in item[1:]]
+                                bezier_points = interpolate_bezier(control_points)
+                                vertices = [Vertex.ByCoordinates(pt.x, -pt.y, 0) for pt in bezier_points]
+                                for i in range(len(vertices)-1):
+                                    start_vertex = vertices[i]
+                                    end_vertex = vertices[i+1]
+                                    edge = Edge.ByStartVertexEndVertex(start_vertex, end_vertex, tolerance=tolerance, silent=False)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+                            elif item[0] == "re":  # Rectangle
+                                x0, y0, x1, y1 = item[1]
+                                vertices = [
+                                    Vertex.ByCoordinates(x0, -y0, 0),
+                                    Vertex.ByCoordinates(x1, -y0, 0),
+                                    Vertex.ByCoordinates(x1, -y1, 0),
+                                    Vertex.ByCoordinates(x0, -y1, 0)
+                                ]
+                                for i in range(len(vertices)-1):
+                                    start_vertex = vertices[i]
+                                    end_vertex = vertices[i+1]
+                                    edge = Edge.ByStartVertexEndVertex(start_vertex, end_vertex, tolerance=tolerance, silent=False)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+                                    edge = Edge.ByStartVertexEndVertex(vertices[-1], vertices[0], tolerance=tolerance, silent=False)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+
+                            elif item[0] == "qu":  # Quadrilateral
+                                quad_points = [pymupdf.Point(pt[0], pt[1]).transform(matrix) for pt in item[1]]
+                                vertices = [Vertex.ByCoordinates(pt.x, -pt.y, 0) for pt in quad_points]
+                                for i in range(len(vertices)-1):
+                                    start_vertex = vertices[i]
+                                    end_vertex = vertices[i+1]
+                                    edge = Edge.ByStartVertexEndVertex(start_vertex, end_vertex, tolerance=tolerance, silent=False)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+                                    edge = Edge.ByStartVertexEndVertex(vertices[-1], vertices[0], tolerance=tolerance, silent=False)
+                                    if not edge == None:
+                                        edge = Topology.SetDictionary(edge, dictionary)  # Set dictionary
+                                        components.append(edge)
+
+                    if len(components) > 0:
+                        if len(components) == 1:
+                            tp_object = components[0]
+                        elif len(components) > 1:
+                            tp_object = Cluster.ByTopologies(components)
+                            if wires == True or faces == True:
+                                tp_object = Topology.SelfMerge(tp_object)
+                        if faces == True:
+                            if Topology.IsInstance(tp_object, "wire"):
+                                if Wire.IsClosed(tp_object):
+                                    tp_object = Face.ByWire(tp_object, silent=True) or tp_object
+                        tp_object = Topology.SetDictionary(tp_object, dictionary)
+                        edges = Topology.Edges(tp_object)
+                        for edge in edges:
+                            edge = Topology.SetDictionary(edge, dictionary)
+                        topologic_entities.append(tp_object)
+
+        return topologic_entities
+
+    @staticmethod
+    def ByPDFPath(path, wires=False, faces=False, includeTypes=[], excludeTypes=[], edgeColorKey="edge_color", edgeWidthKey="edge_width", faceColorKey="face_color", faceOpacityKey="face_opacity", tolerance=0.0001, silent=False):
+        """
+        Import PDF file and convert its entities to topologies.
+
+        Parameters
+        ----------
+        path : path
+            The input path to the PDF file
+        wires : bool , optional
+            If set to True, wires will be constructed when possible. The default is True.
+        faces : bool , optional
+            If set to True, faces will be constructed when possible. The default is True.
+        includeTypes : list , optional
+            A list of PDF object types to include in the returned result. The default is [] which means all PDF objects will be included.
+            The possible strings to include in this list are: ["line", "curve", "rectangle", "quadrilateral"]
+        excludeTypes : list , optional
+            A list of PDF object types to exclude from the returned result. The default is [] which mean no PDF object type will be excluded.
+            The possible strings to include in this list are: ["line", "curve", "rectangle", "quadrilateral"]
+        edgeColorKey : str , optional
+            The dictionary key under which to store the edge color. The default is None.
+        edgeWidthKey : str , optional
+            The dictionary key under which to store the edge width. The default is None.
+        faceColorKey : str , optional
+            The dictionary key under which to store the face color. The default is None.
+        faceOpacityKey : str , optional
+            The dictionary key under which to store the face opacity. The default is None.
+        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
+        -------
+        list
+        A list of Topologic entities (edges, wires, faces, clusters) with attached dictionaries.
+
+        """
+        import os
+        import warnings
+        try:
+            import pymupdf  # PyMuPDF
+        except:
+            if not silent:
+                print("Topology.ByPDFPath - Warning: Installing required PyMuPDF library.")
+            try:
+                os.system("pip install PyMuPDF")
+            except:
+                os.system("pip install PyMuPDF --user")
+            try:
+                import pymupdf
+                if not silent:
+                    print("Topology.ByPDFPath - Information: PyMUDF library installed correctly.")
+            except:
+                if not silent:
+                    warnings.warn("Topology.ByPDFPath - Error: Could not import PyMuPDF. Please try to install PyMuPDF manually. Returning None.")
+                return None
+        if not isinstance(path, str):
+            if not silent:
+                print("Topology.ByPDFPath - Error: the input path is not a valid path. Returning None.")
+            return None
+        if not os.path.exists(path):
+            if not silent:
+                print("Topology.ByPDFPath - Error: The specified path does not exist. Returning None.")
+            return None
+        pdf_file = pymupdf.open(path)
+        if not pdf_file:
+            if not silent:
+                print("Topology.ByPDFPath - Error: Could not open the PDF file. Returning None.")
+            return None
+
+        topologies = Topology.ByPDFFile(file=pdf_file,
+                            wires=wires,
+                            faces=faces,
+                            includeTypes = includeTypes,
+                            excludeTypes = excludeTypes,
+                            edgeColorKey=edgeColorKey,
+                            edgeWidthKey=edgeWidthKey,
+                            faceColorKey=faceColorKey,
+                            faceOpacityKey=faceOpacityKey,
+                            tolerance=tolerance,
+                            silent=silent)
+        pdf_file.close()
+        return topologies
+
     @staticmethod
     def ByBREPString(string):
         """
@@ -7696,6 +8023,8 @@ 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"):
@@ -8295,32 +8624,42 @@ class Topology():
             The list of subtopologies.
 
         """
+        from topologicpy.Face import Face
+
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.SubTopologies - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
         if Topology.TypeAsString(topology).lower() == subTopologyType.lower():
             return [topology]
+        
         subTopologies = []
-        if subTopologyType.lower() == "vertex":
-            _ = topology.Vertices(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "edge":
-            _ = topology.Edges(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "wire":
-            _ = topology.Wires(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "face":
-            _ = topology.Faces(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "shell":
-            _ = topology.Shells(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "cell":
-            _ = topology.Cells(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "cellcomplex":
-            _ = topology.CellComplexes(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "cluster":
-            _ = topology.Clusters(None, subTopologies) # Hook to Core
-        elif subTopologyType.lower() == "aperture":
-            _ = topology.Apertures(None, subTopologies) # Hook to Core
-        if not subTopologies:
-            return [] # Make sure to return an empty list instead of None
+
+        # Spcecial case for faces to return vertices in CW/CCW order.
+        if Topology.IsInstance(topology, "face") and (subTopologyType.lower() == "vertex" or subTopologyType.lower() == "edge"):
+            wires = Face.Wires(topology)
+            for wire in wires:
+                subTopologies += Topology.SubTopologies(wire, subTopologyType=subTopologyType)
+        else:
+            if subTopologyType.lower() == "vertex":
+                _ = topology.Vertices(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "edge":
+                _ = topology.Edges(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "wire":
+                _ = topology.Wires(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "face":
+                _ = topology.Faces(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "shell":
+                _ = topology.Shells(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "cell":
+                _ = topology.Cells(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "cellcomplex":
+                _ = topology.CellComplexes(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "cluster":
+                _ = topology.Clusters(None, subTopologies) # Hook to Core
+            elif subTopologyType.lower() == "aperture":
+                _ = topology.Apertures(None, subTopologies) # Hook to Core
+            if not subTopologies:
+                return [] # Make sure to return an empty list instead of None
         return subTopologies
 
     

topologicpy/Vertex.py

@@ -34,6 +34,57 @@ except:
         warnings.warn("Vertex - Error: Could not import numpy.")
 
 class Vertex():
+    @staticmethod
+    def AlignCoordinates(vertex, xList=None, yList=None, zList=None, transferDictionary=False, mantissa=6, silent=False):
+        """
+            Aligns the coordinates of the input vertex with the list of x,y, and z coordinates.
+
+            Parameters
+            ----------
+            vertex : topologic_core.Vertex
+                The input vertex.
+            xList : list , optional
+                The input numerical list of x-coordinates. The default is None.
+            yList : list , optional
+                The input numerical list of y-coordinates. The default is None.
+            zList : list , optional
+                The input numerical list of z-coordinates. The default is None.
+            transferDictionary : bool , optional
+                if set to True, the dictionary of the input vertex is transferred to the new vertex.
+            mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+            silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+            
+            Returns
+            -------
+            topologic_core.Vertex
+                The created vertex aligned to the input list of x,y, and z coordinates.
+        
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        if not Topology.IsInstance(vertex, "vertex"):
+            if not silent:
+                print("Vertex.AlignCoordinates - Error: The input vertex parameter is not a topologic vertex. Returning None.")
+            return None
+        
+        closest_x, closest_y, closest_z = Vertex.Coordinates(vertex, mantissa=mantissa)
+        if isinstance(xList, list):
+            if len(xList) > 0:
+                closest_x = xList[Helper.ClosestMatch(closest_x, xList)]
+        if isinstance(yList, list):
+            if len(yList) > 0:
+                closest_y = yList[Helper.ClosestMatch(closest_y, yList)]
+        if isinstance(zList, list):
+            if len(zList) > 0:
+                closest_z = zList[Helper.ClosestMatch(closest_z, zList)]
+        return_vertex = Vertex.ByCoordinates(closest_x, closest_y, closest_z)
+        if transferDictionary == True:
+            return_vertex = Topology.SetDictionary(return_vertex, Topology.Dictionary(vertex), silent=silent)
+        return return_vertex
+
     @staticmethod
     def AreCollinear(vertices: list, mantissa: int = 6, tolerance: float = 0.0001):
         """

topologicpy/Wire.py

@@ -3242,18 +3242,27 @@ class Wire():
         return roof
     
     @staticmethod
-    def Simplify(wire, tolerance=0.0001):
+    def Simplify(wire, method='douglas-peucker', tolerance=0.0001, silent=False):
         """
-        Simplifies the input wire edges based on the Douglas Peucker algorthim. See https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
-        Part of this code was contributed by gaoxipeng. See https://github.com/wassimj/topologicpy/issues/35
+        Simplifies the input wire edges based on the selected algorithm: Douglas-Peucker or Visvalingam–Whyatt.
         
         Parameters
         ----------
         wire : topologic_core.Wire
             The input wire.
+        method : str, optional
+            The simplification method to use: 'douglas-peucker' or 'visvalingam-whyatt' or 'reumann-witkam'.
+            The default is 'douglas-peucker'.
         tolerance : float , optional
-            The desired tolerance. The default is 0.0001. Edges shorter than this length will be removed.
-
+            The desired tolerance.
+            If using the douglas-peucker method, edge lengths shorter than this amount will be removed.
+            If using the visvalingam-whyatt method, triangulare areas less than is amount will be removed.
+            If using the Reumann-Witkam method, the tolerance specifies the maximum perpendicular distance allowed
+            between any point and the current line segment; points falling within this distance are discarded.
+            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.Wire
@@ -3264,7 +3273,7 @@ class Wire():
         from topologicpy.Edge import Edge
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
-        
+
         def perpendicular_distance(point, line_start, line_end):
             # Calculate the perpendicular distance from a point to a line segment
             x0 = point.X()
@@ -3284,15 +3293,12 @@ class Wire():
                 points = wire
             else:
                 points = Topology.Vertices(wire)
-                # points.insert(0, points.pop())
             if len(points) <= 2:
                 return points
 
-            # Use the first and last points in the list as the starting and ending points
             start_point = points[0]
             end_point = points[-1]
 
-            # Find the point with the maximum distance
             max_distance = 0
             max_index = 0
 
@@ -3302,19 +3308,79 @@ class Wire():
                     max_distance = d
                     max_index = i
 
-            # If the maximum distance is less than the tolerance, no further simplification is needed
             if max_distance <= tolerance:
                 return [start_point, end_point]
 
-            # Recursively simplify
             first_segment = douglas_peucker(points[:max_index + 1], tolerance)
             second_segment = douglas_peucker(points[max_index:], tolerance)
 
-            # Merge the two simplified segments
             return first_segment[:-1] + second_segment
-        
+
+        def visvalingam_whyatt(wire, tolerance):
+            if isinstance(wire, list):
+                points = wire
+            else:
+                points = Topology.Vertices(wire)
+
+            if len(points) <= 2:
+                return points
+
+            # Calculate the effective area for each point except the first and last
+            def effective_area(p1, p2, p3):
+                # Triangle area formed by p1, p2, and p3
+                return 0.5 * abs(p1.X() * (p2.Y() - p3.Y()) + p2.X() * (p3.Y() - p1.Y()) + p3.X() * (p1.Y() - p2.Y()))
+
+            # Keep track of effective areas
+            areas = [None]  # First point has no area
+            for i in range(1, len(points) - 1):
+                area = effective_area(points[i - 1], points[i], points[i + 1])
+                areas.append((area, i))
+            areas.append(None)  # Last point has no area
+
+            # Sort points by area in ascending order
+            sorted_areas = sorted([(area, idx) for area, idx in areas[1:-1] if area is not None])
+
+            # Remove points with area below the tolerance threshold
+            remove_indices = {idx for area, idx in sorted_areas if area < tolerance}
+
+            # Construct the simplified list of points
+            simplified_points = [point for i, point in enumerate(points) if i not in remove_indices]
+
+            return simplified_points
+
+        def reumann_witkam(wire, tolerance):
+            if isinstance(wire, list):
+                points = wire
+            else:
+                points = Topology.Vertices(wire)
+            
+            if len(points) <= 2:
+                return points
+
+            simplified_points = [points[0]]
+            start_point = points[0]
+            i = 1
+
+            while i < len(points) - 1:
+                end_point = points[i]
+                next_point = points[i + 1]
+                dist = perpendicular_distance(next_point, start_point, end_point)
+
+                # If the next point is outside the tolerance corridor, add the current end_point
+                if dist > tolerance:
+                    simplified_points.append(end_point)
+                    start_point = end_point
+
+                i += 1
+
+            # Always add the last point
+            simplified_points.append(points[-1])
+
+            return simplified_points
+
         if not Topology.IsInstance(wire, "Wire"):
-            print("Wire.Simplify = Error: The input wire parameter is not a Wire. Returning None.")
+            if not silent:
+                print("Wire.Simplify = Error: The input wire parameter is not a Wire. Returning None.")
             return None
         if not Wire.IsManifold(wire):
             wires = Wire.Split(wire)
@@ -3324,12 +3390,31 @@ class Wire():
                     if Edge.Length(w) > tolerance:
                         new_wires.append(w)
                 elif Topology.IsInstance(w, "Wire"):
-                    new_wires.append(Wire.Simplify(w, tolerance=tolerance))
+                    new_wires.append(Wire.Simplify(w, method=method, tolerance=tolerance, silent=silent))
             return_wire = Topology.SelfMerge(Cluster.ByTopologies(new_wires))
             return return_wire
+
+        new_vertices = []
+        if 'douglas' in method.lower(): #douglas-peucker
+            new_vertices = douglas_peucker(wire, tolerance=tolerance)
+        elif 'vis' in method.lower(): # 'visvalingam-whyatt'
+            new_vertices = visvalingam_whyatt(wire, tolerance=tolerance)
+        elif 'reu' in method.lower(): # 'reumann-witkam'
+            new_vertices = reumann_witkam(wire, tolerance=tolerance)
+        else:
+            if not silent:
+                print(f"Wire.Simplify - Warning: Unknown method ({method}). Please use 'douglas-peucker' or 'visvalingam-whyatt' or 'reumann-witkam'. Defaulting to 'douglas-peucker'.")
+            new_vertices = douglas_peucker(wire, tolerance=tolerance)
         
-        new_vertices = douglas_peucker(wire, tolerance=tolerance)
+        if len(new_vertices) < 2:
+            if not silent:
+                print("Wire.Simplify - Warning: Could not generate enough vertices for a simplified wire. Returning the original wire.")
+            wire
         new_wire = Wire.ByVertices(new_vertices, close=Wire.IsClosed(wire))
+        if not Topology.IsInstance(new_wire, "wire"):
+            if not silent:
+                print("Wire.Simplify - Warning: Could not generate a simplified wire. Returning the original wire.")
+            return wire
         return new_wire
 
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.76'
+__version__ = '0.7.78'

{topologicpy-0.7.76.dist-info → topologicpy-0.7.78.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.76
+Version: 0.7.78
 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
@@ -36,6 +36,7 @@ Requires-Dist: tqdm
 Requires-Dist: plotly
 Requires-Dist: lark
 Requires-Dist: specklepy
+Requires-Dist: webcolors
 Requires-Dist: topologic_core>=7.0.1
 Provides-Extra: test
 Requires-Dist: pytest-xdist>=2.4.0; extra == "test"

{topologicpy-0.7.76.dist-info → topologicpy-0.7.78.dist-info}/RECORD

@@ -10,27 +10,27 @@ topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=0AsGoz48pGTye_F4KcJopNjD9STeQ50LHc6PPvERFaA,31932
 topologicpy/Edge.py,sha256=9u9SdUxuenLUIK26xwFvPoYV34p0dCfXmHHBxdgvAdM,67164
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
-topologicpy/Face.py,sha256=9E3AaTCkcENwmTbFgyZKkdmhjVXHO_q9clQSji2685M,124363
-topologicpy/Graph.py,sha256=BuSg8ilbZd2Qqoenmtw5FrkSe1fDLFS6jshljvq4dOs,416822
+topologicpy/Face.py,sha256=mS7LI3qIo2jfQbibpInArRfXMmTZd7xU8IdvRYUIGSU,124747
+topologicpy/Graph.py,sha256=ZhMVB6ntuhIgTrKLUPryeAJFFBF0cnRsNgESbaohOiw,416914
 topologicpy/Grid.py,sha256=9N6PE84qCm40TRi2WtlVZSBwXXr47zHpscEpZHg_JW4,18205
 topologicpy/Helper.py,sha256=Sv35czP_j0oLDeJcN8usswUm4U3auiK1LQ_Z_HBvxxg,21716
 topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=t52hgE9cVsqkGc7m7fjRsLnyfRHakVHwdvF4ms7ow78,22342
-topologicpy/Plotly.py,sha256=VNUHRUNu4NUmf3HScQRml3TcwHe_ZoqXjqwttGSuU88,112642
+topologicpy/Plotly.py,sha256=cI1I6F-hGuN4dG-O-QvByipP0H1n5WsNG7_d0Y6_FNQ,113509
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=8OJjlWk9eCZ3uGOTht6ZVrcMczCafw-YWoDGueaz7eg,87673
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=J1eTBp8esd9jwcQ4fY82uTjJtj6r9WiaGIZmevRxxDQ,406736
+topologicpy/Topology.py,sha256=W4cUFsRurb20PkoN_xJ_JfPCzqF1WWxmVdRcbjINi2w,425776
 topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
-topologicpy/Vertex.py,sha256=ZS6xK89JKokBKc0W8frdRhhuzR8c-dI1TTLt7pTf1iA,71032
-topologicpy/Wire.py,sha256=eVet2OToVsXi9AkDYo35LpfMPqJ6aKGD6QkiU4-Jvs8,182271
+topologicpy/Vertex.py,sha256=mcLJaWFCct03dkVmT25wAl6k0k2EaYvB1PWNO9WQHWg,73465
+topologicpy/Wire.py,sha256=pLhdos_kZwvIdzsQlVGb2jtZ4dK8ATTmEsZHDnAGBxk,185972
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=3M8WghUyEKh4Nub9zc52IBDUVRayyZVk2cK9zf5M-VY,23
-topologicpy-0.7.76.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.76.dist-info/METADATA,sha256=iMOr84bFL_JI4Gr37GGBrxyIb6i7TOZxJaCKcIHHj_0,10488
-topologicpy-0.7.76.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.76.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.76.dist-info/RECORD,,
+topologicpy/version.py,sha256=EWhF8BAhkJGx-tk4Su0QKSe1yJ5s9S0qkdf3KEnEEqE,23
+topologicpy-0.7.78.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.78.dist-info/METADATA,sha256=aVX5f6Z7-BS3b71jkQKden7ENVrgrXpkZgLkNdRUcH0,10513
+topologicpy-0.7.78.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.78.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.78.dist-info/RECORD,,