topologicpy 0.7.47__py3-none-any.whl → 0.7.49__py3-none-any.whl

topologicpy/Cell.py

@@ -253,6 +253,52 @@ class Cell():
         faces = Topology.SubTopologies(shell, subTopologyType="face")
         return Cell.ByFaces(faces, planarize=planarize, tolerance=tolerance)
     
+    
+    @staticmethod
+    def ByShells(externalBoundary, internalBoundaries: list = [], tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a cell from the input external boundary (closed shell) and the input list of internal boundaries (closed shells).
+
+        Parameters
+        ----------
+        externalBoundary : topologic_core.Shell
+            The input external boundary.
+        internalBoundaries : list , optional
+            The input list of internal boundaries (closed shells). The default is an empty list.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The created cell.
+
+        """
+        from topologicpy.Shell import Shell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        
+        if not Topology.IsInstance(externalBoundary, "Shell"):
+            if not silent:
+                print("Cell.ByShells - Error: The input externalBoundary parameter is not a valid topologic shell. Returning None.")
+            return None
+        if not Shell.IsClosed(externalBoundary):
+            if not silent:
+                print("Cell.ByShells - Error: The input externalBoundary parameter is not a closed topologic shell. Returning None.")
+            return None
+        ibList = [Cell.ByShell(s) for s in internalBoundaries if Topology.IsInstance(s, "Shell") and Shell.IsClosed(s)]
+        cell = Cell.ByShell(externalBoundary)
+        if len(ibList) > 0:
+            inner_cluster =Cluster.ByTopologies(ibList)
+            cell = Topology.Difference(cell, inner_cluster)
+            if not Topology.IsInstance(cell, "Cell"):
+                if not silent:
+                    print("Cell.ByShells - Error: Could not create cell. Returning None.")
+                return None
+        return cell
+
     @staticmethod
     def ByThickenedFace(face, thickness: float = 1.0, bothSides: bool = True, reverse: bool = False,
                             planarize: bool = False, tolerance: float = 0.0001):

topologicpy/PyG.py

@@ -16,25 +16,104 @@
 
 import os
 import copy
-import numpy as np
-import pandas as pd
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch_geometric.data import Data, Dataset
-from torch_geometric.loader import DataLoader
-from torch_geometric.nn import SAGEConv, global_mean_pool, global_max_pool, global_add_pool
-from torch.utils.data.sampler import SubsetRandomSampler
-from sklearn.model_selection import KFold
-from sklearn.metrics import accuracy_score
-from tqdm.auto import tqdm
+import warnings
 import gc
 
-import torch
-from torch.utils.data import Dataset
-
-import torch
-from torch.utils.data import Dataset
+try:
+    import numpy as np
+except:
+    print("PyG - Installing required numpy library.")
+    try:
+        os.system("pip install numpy")
+    except:
+        os.system("pip install numpy --user")
+    try:
+        import numpy as np
+        print("PyG - numpy library installed successfully.")
+    except:
+        warnings.warn("PyG - Error: Could not import numpy.")
+
+try:
+    import pandas as pd
+except:
+    print("PyG - Installing required pandas library.")
+    try:
+        os.system("pip install pandas")
+    except:
+        os.system("pip install pandas --user")
+    try:
+        import numpy as np
+        print("PyG - pandas library installed successfully.")
+    except:
+        warnings.warn("PyG - Error: Could not import pandas.")
+
+try:
+    from tqdm.auto import tqdm
+except:
+    print("PyG - Installing required tqdm library.")
+    try:
+        os.system("pip install tqdm")
+    except:
+        os.system("pip install tqdm --user")
+    try:
+        from tqdm.auto import tqdm
+        print("PyG - tqdm library installed correctly.")
+    except:
+        raise Exception("PyG - Error: Could not import tqdm.")
+
+try:
+    import torch
+    import torch.nn as nn
+    import torch.nn.functional as F
+    from torch.utils.data.sampler import SubsetRandomSampler
+except:
+    print("PyG - Installing required torch library.")
+    try:
+        os.system("pip install torch")
+    except:
+        os.system("pip install torch --user")
+    try:
+        import torch
+        import torch.nn as nn
+        import torch.nn.functional as F
+        from torch.utils.data.sampler import SubsetRandomSampler
+        print("PyG - torch library installed correctly.")
+    except:
+        warnings.warn("PyG - Error: Could not import torch.")
+
+try:
+    from torch_geometric.data import Data, Dataset
+    from torch_geometric.loader import DataLoader
+    from torch_geometric.nn import SAGEConv, global_mean_pool, global_max_pool, global_add_pool
+except:
+    print("PyG - Installing required torch_geometric library.")
+    try:
+        os.system("pip install torch_geometric")
+    except:
+        os.system("pip install torch_geometric --user")
+    try:
+        from torch_geometric.data import Data, Dataset
+        from torch_geometric.loader import DataLoader
+        from torch_geometric.nn import SAGEConv, global_mean_pool, global_max_pool, global_add_pool
+        print("PyG - torch_geometric library installed correctly.")
+    except:
+        warnings.warn("PyG - Error: Could not import torch.")
+
+try:
+    from sklearn.model_selection import KFold
+    from sklearn.metrics import accuracy_score
+except:
+    print("PyG - Installing required scikit-learn library.")
+    try:
+        os.system("pip install -U scikit-learn")
+    except:
+        os.system("pip install -U scikit-learn --user")
+    try:
+        from sklearn.model_selection import KFold
+        from sklearn.metrics import accuracy_score
+        print("PyG - scikit-learn library installed correctly.")
+    except:
+        warnings.warn("PyG - Error: Could not import scikit. Please install it manually.")
 
 class CustomGraphDataset(Dataset):
     def __init__(self, root=None, data_list=None, indices=None, node_level=False, graph_level=True, 

topologicpy/Shell.py

@@ -383,6 +383,7 @@ class Shell():
     def ByWires(wires: list, triangulate: bool = True, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a shell by lofting through the input wires
+        
         Parameters
         ----------
         wires : list

topologicpy/Sun.py

@@ -261,6 +261,7 @@ class Sun():
         float
             The altitude angle.
         """
+
         import os
         import warnings
         import math
@@ -399,6 +400,7 @@ class Sun():
         list
             The sun vector pointing from the location of the sun towards the origin.
         """
+        
         from topologicpy.Vector import Vector
         azimuth = Sun.Azimuth(latitude=latitude, longitude=longitude, date=date)
         altitude = Sun.Altitude(latitude=latitude, longitude=longitude, date=date)
@@ -758,14 +760,12 @@ class Sun():
         -------
         dict
             A dictionary of the sun diagram shapes. The keys in this dictionary are:
-            - 'date_paths': These are the sun paths (wire) for the winter solstice, equinox, and summer solstice
-            - 'hourly_paths': These are the figure-8 (wire) for the sun location on the same hour on each selected day of the year.
-            - 'shell': This is the total surface (shell) of the sun paths. This is included only if the shell option is set to True.
-            - 'compass': This is the compass (shell) on the ground. It is made of 36 sides and 10 rings. This is included only
-               if the compass option is set to True.
-            - 'center' : This is a cross-shape (wire) at the center of the diagram. This is included only if the compass option is set to True.
-            - 'ground' : This is a circle (face) on the ground. It is made of 36 sides. This is included only if
-               the compass option is set to False.
+            'date_paths': These are the sun paths (wire) for the winter solstice, equinox, and summer solstice
+            'hourly_paths': These are the figure-8 (wire) for the sun location on the same hour on each selected day of the year.
+            'shell': This is the total surface (shell) of the sun paths. This is included only if the shell option is set to True.
+            'compass': This is the compass (shell) on the ground. It is made of 36 sides and 10 rings. This is included only if the compass option is set to True.
+            'center' : This is a cross-shape (wire) at the center of the diagram. This is included only if the compass option is set to True.
+            'ground' : This is a circle (face) on the ground. It is made of 36 sides. This is included only if the compass option is set to False.
         """
 
         from datetime import datetime

topologicpy/Topology.py

@@ -205,6 +205,59 @@ class Topology():
         """
         Adds the input list of apertures to the input topology or to its subtopologies based on the input subTopologyType.
 
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        apertures : list
+            The input list of apertures.
+        exclusive : bool , optional
+            If set to True, one (sub)topology will accept only one aperture. Otherwise, one (sub)topology can accept multiple apertures. The default is False.
+        subTopologyType : string , optional
+            The subtopology type to which to add the apertures. This can be "cell", "face", "edge", or "vertex". It is case insensitive. If set to None, the apertures will be added to the input topology. The default is None.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.001. This is larger than the usual 0.0001 as it seems to work better.
+
+        Returns
+        -------
+        topologic_core.Topology
+            The input topology with the apertures added to it.
+
+        """
+        from topologicpy.Dictionary import Dictionary
+        
+        if not Topology.IsInstance(topology, "Topology"):
+            print("Topology.AddApertures - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if not apertures:
+            return topology
+        if not isinstance(apertures, list):
+            print("Topology.AddApertures - Error: the input apertures parameter is not a list. Returning None.")
+            return None
+        apertures = [x for x in apertures if Topology.IsInstance(x, "Topology")]
+        if len(apertures) < 1:
+            return topology
+        if not subTopologyType:
+            subTopologyType = "self"
+        if not subTopologyType.lower() in ["self", "cell", "face", "edge", "vertex"]:
+            print("Topology.AddApertures - Error: the input subtopology type parameter is not a recognized type. Returning None.")
+            return None
+        
+        for aperture in apertures:
+            d = Topology.Dictionary(aperture)
+            d = Dictionary.SetValueAtKey(d, "type", "aperture")
+            aperture = Topology.SetDictionary(aperture, d)
+        
+        topology = Topology.AddContent(topology, apertures, subTopologyType=subTopologyType, tolerance=tolerance)
+        return topology
+
+
+
+    @staticmethod
+    def AddApertures_old(topology, apertures, exclusive=False, subTopologyType=None, tolerance=0.001):
+        """
+        Adds the input list of apertures to the input topology or to its subtopologies based on the input subTopologyType.
+
         Parameters
         ----------
         topology : topologic_core.Topology
@@ -794,6 +847,9 @@ class Topology():
             The list of apertures belonging to the input topology.
 
         """
+
+        from topologicpy.Dictionary import Dictionary
+
         if not Topology.IsInstance(topology, "Topology"):
             print("Topology.Apertures - Error: the input topology parameter is not a valid topology. Returning None.")
             return None
@@ -802,6 +858,13 @@ class Topology():
         subTopologies = []
         if not subTopologyType:
             _ = topology.Apertures(apertures)
+            contents = Topology.Contents(topology)
+            for content in contents:
+                d = Topology.Dictionary(content)
+                if len(Dictionary.Keys(d)) > 0:
+                    type = Dictionary.ValueAtKey(d,"type")
+                    if type == "aperture":
+                        apertures.append(content)
         elif subTopologyType.lower() == "vertex":
             subTopologies = Topology.Vertices(topology)
         elif subTopologyType.lower() == "edge":
@@ -2325,12 +2388,249 @@ class Topology():
         if not file:
             print("Topology.ByJSONFile - Error: the input file parameter is not a valid file. Returning None.")
             return None
-        jsonData = json.load(file)
-        jsonString = json.dumps(jsonData)
-        return Topology.ByJSONString(jsonString, tolerance=tolerance)
+        json_string = json.load(file)
+        #jsonData = json.load(file)
+        #jsonString = json.dumps(jsonData)
+        return Topology.ByJSONString(json_string, tolerance=tolerance)
+    
+    @staticmethod
+    def ByJSONPath(path, tolerance=0.0001):
+        """
+        Imports the topology from a JSON file.
+
+        Parameters
+        ----------
+        path : str
+            The file path to the json file.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of imported topologies.
+
+        """
+        import json
+        if not path:
+            print("Topology.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
+            return None
+        with open(path) as file:
+            json_string = json.load(file)
+        entities = Topology.ByJSONString(json_string, tolerance=tolerance)
+        return entities
     
     @staticmethod
-    def ByJSONString(string, progressBar=False, tolerance=0.0001):
+    def ByJSONString(string, tolerance=0.0001):
+        """
+        Imports the topology from a JSON string.
+
+        Parameters
+        ----------
+        string : str
+            The input JSON string.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list or topologicpy.Topology
+            The list of imported topologies. If the list only contains one element, it returns that element.
+
+        """
+        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.CellComplex import CellComplex
+        from topologicpy.Dictionary import Dictionary
+
+        # Containers for created entities
+        vertices = {}
+        edges = {}
+        wires = {}
+        faces = {}
+        shells = {}
+        cells = {}
+        cell_complexes = {}
+
+        vertex_apertures = []
+        edge_apertures = []
+        face_apertures = []
+        # Step 2: Create Entities and handle apertures
+        for entity in string:
+            entity_type = entity['type']
+            entity_dict = Dictionary.ByKeysValues(keys=list(entity['dictionary'].keys()),
+                                                values=list(entity['dictionary'].values()))
+
+            parent_entity = None
+
+            # Create basic topological entities
+            if entity_type == 'Vertex':
+                parent_entity = Vertex.ByCoordinates(*entity['coordinates'])
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                vertices[entity['uuid']] = parent_entity
+
+            elif entity_type == 'Edge':
+                vertex1 = vertices[entity['vertices'][0]]
+                vertex2 = vertices[entity['vertices'][1]]
+                parent_entity = Edge.ByVertices([vertex1, vertex2])
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                edges[entity['uuid']] = parent_entity
+
+            elif entity_type == 'Wire':
+                wire_edges = [edges[uuid] for uuid in entity['edges']]
+                parent_entity = Wire.ByEdges(wire_edges)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                wires[entity['uuid']] = parent_entity
+
+            elif entity_type == 'Face':
+                face_wires = [wires[uuid] for uuid in entity['wires']]
+                if len(face_wires) > 1:
+                    parent_entity = Face.ByWires(face_wires[0], face_wires[1:])
+                else:
+                    parent_entity = Face.ByWire(face_wires[0])
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                faces[entity['uuid']] = parent_entity
+
+            elif entity_type == 'Shell':
+                shell_faces = [faces[uuid] for uuid in entity['faces']]
+                parent_entity = Shell.ByFaces(shell_faces)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                shells[entity['uuid']] = parent_entity
+
+            elif entity_type == 'Cell':
+                cell_shells = [shells[uuid] for uuid in entity['shells']]
+                if len(cell_shells) > 1:
+                    parent_entity = Cell.ByShells(cell_shells[0], cell_shells[1:])
+                else:
+                    parent_entity = Cell.ByShell(cell_shells[0])
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                cells[entity['uuid']] = parent_entity
+
+            elif entity_type == 'CellComplex':
+                complex_cells = [cells[uuid] for uuid in entity['cells']]
+                parent_entity = CellComplex.ByCells(complex_cells)
+                parent_entity = Topology.SetDictionary(parent_entity, entity_dict)
+                cell_complexes[entity['uuid']] = parent_entity
+
+            # Step 3: Handle apertures within each entity
+            if 'apertures' in entity:
+                # Containers for created entities
+                ap_vertices = {}
+                ap_edges = {}
+                ap_wires = {}
+                ap_faces = {}
+                for aperture_list in entity['apertures']:
+                    types = [aperture_data['type'] for aperture_data in aperture_list]
+                    save_vertex = False
+                    save_edge = False
+                    save_wire = False
+                    save_face = False
+
+                    if 'Face' in types:
+                        save_face = True
+                    elif 'Wire' in types:
+                        save_wire = True
+                    elif 'Edge' in types:
+                        save_edge = True
+                    elif 'Vertex' in types:
+                        save_vertex = True
+
+                    apertures = []
+                    for aperture_data in aperture_list:
+                        aperture_type = aperture_data['type']
+                        aperture_dict = Dictionary.ByKeysValues(keys=list(aperture_data['dictionary'].keys()),
+                                                                values=list(aperture_data['dictionary'].values()))
+                        
+                        if aperture_type == 'Vertex':
+                            aperture_entity = Vertex.ByCoordinates(*aperture_data['coordinates'])
+                            aperture_entity = Topology.SetDictionary(aperture_entity, aperture_dict)
+                            ap_vertices[aperture_data['uuid']] = aperture_entity
+                            if save_vertex == True:
+                                apertures.append(aperture_entity)
+                        
+                        elif aperture_type == 'Edge':
+                            vertex1 = ap_vertices[aperture_data['vertices'][0]]
+                            vertex2 = ap_vertices[aperture_data['vertices'][1]]
+                            aperture_entity = Edge.ByVertices([vertex1, vertex2])
+                            aperture_entity = Topology.SetDictionary(aperture_entity, aperture_dict)
+                            ap_edges[aperture_data['uuid']] = aperture_entity
+                            if save_edge == True:
+                                apertures.append(aperture_entity)
+
+                        elif aperture_type == 'Wire':
+                            wire_edges = [ap_edges[uuid] for uuid in aperture_data['edges']]
+                            aperture_entity = Wire.ByEdges(wire_edges)
+                            aperture_entity = Topology.SetDictionary(aperture_entity, aperture_dict)
+                            ap_wires[aperture_data['uuid']] = aperture_entity
+                            if save_wire == True:
+                                apertures.append(aperture_entity)
+
+                        elif aperture_type == 'Face':
+                            face_wires = [ap_wires[uuid] for uuid in aperture_data['wires']]
+                            if len(face_wires) > 1:
+                                aperture_entity = Face.ByWires(face_wires[0], face_wires[1:])
+                            else:
+                                aperture_entity = Face.ByWire(face_wires[0])
+                            aperture_entity = Topology.SetDictionary(aperture_entity, aperture_dict)
+                            ap_faces[aperture_data['uuid']] = aperture_entity
+                            if save_face == True:
+                                apertures.append(aperture_entity)
+                            
+                    # Assign the built apertures to the parent entity
+                    if len(apertures) > 0:
+                        if entity_type == "Face":
+                            face_apertures += apertures
+                        elif entity_type == 'Edge':
+                            edge_apertures += apertures
+                        elif entity_type == 'Vertex':
+                            vertex_apertures += apertures
+
+                # Update the parent entity in its respective container
+                if entity_type == 'Vertex':
+                    vertices[entity['uuid']] = parent_entity
+                elif entity_type == 'Edge':
+                    edges[entity['uuid']] = parent_entity
+                elif entity_type == 'Wire':
+                    wires[entity['uuid']] = parent_entity
+                elif entity_type == 'Face':
+                    faces[entity['uuid']] = parent_entity
+                elif entity_type == 'Shell':
+                    shells[entity['uuid']] = parent_entity
+                elif entity_type == 'Cell':
+                    cells[entity['uuid']] = parent_entity
+                elif entity_type == 'CellComplex':
+                    cell_complexes[entity['uuid']] = parent_entity
+            
+            d = Topology.Dictionary(parent_entity)
+            top_level = Dictionary.ValueAtKey(d, "toplevel")
+        tp_vertices = list(vertices.values())
+        tp_edges = list(edges.values())
+        tp_wires = list(wires.values())
+        tp_faces = list(faces.values())
+        tp_shells = list(shells.values())
+        tp_cells = list(cells.values())
+        tp_cell_complexes = list(cell_complexes.values())
+        everything = tp_vertices + tp_edges + tp_wires + tp_faces + tp_shells + tp_cells + tp_cell_complexes
+        top_level_list = []
+        for entity in everything:
+            d = Topology.Dictionary(entity)
+            top_level = Dictionary.ValueAtKey(d, "toplevel")
+            if top_level == 1:
+                if len(face_apertures) > 0:
+                    entity = Topology.AddApertures(entity, face_apertures, subTopologyType="Face", tolerance=tolerance)
+                if len(edge_apertures) > 0:
+                    entity = Topology.AddApertures(entity, edge_apertures, subTopologyType="Edge", tolerance=0.001)
+                if len(vertex_apertures) > 0:
+                    entity = Topology.AddApertures(entity, vertex_apertures, subTopologyType="Vertex", tolerance=0.001)
+                top_level_list.append(entity)
+        return top_level_list
+    
+    @staticmethod
+    def ByJSONString_old(string, progressBar=False, tolerance=0.0001):
         """
         Imports the topology from a JSON string.
 
@@ -2797,32 +3097,6 @@ class Topology():
             return return_topologies[0]
         else:
             return return_topologies
-    
-    @staticmethod
-    def ByJSONPath(path, tolerance=0.0001):
-        """
-        Imports the topology from a JSON file.
-
-        Parameters
-        ----------
-        path : str
-            The file path to the json file.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-
-        Returns
-        -------
-        list
-            The list of imported topologies.
-
-        """
-        if not path:
-            print("Topology.ByJSONPath - Error: the input path parameter is not a valid path. Returning None.")
-            return None
-        data = None
-        with open(path) as file:
-            data = Topology.ByJSONFile(file=file, tolerance=tolerance)
-        return data
 
     @staticmethod
     def ByOBJFile(objFile, mtlFile = None,

topologicpy/Vertex.py

@@ -316,14 +316,14 @@ class Vertex():
         Returns the centroid of the input list of vertices.
 
         Parameters
-        -----------
+        ----------
         vertices : list
             The input list of vertices
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
-        Return
-        ----------
+        Returns
+        -------
         topologic_core.Vertex
             The computed centroid of the input list of vertices
         
@@ -350,16 +350,17 @@ class Vertex():
         Sorts the input list of vertices in a clockwise fashion. This method assumes that the vertices are on the XY plane. The Z coordinate is ignored.
 
         Parameters
-        -----------
+        ----------
         vertices : list
             The input list of vertices
 
-        Return
-        -----------
+        Returns
+        -------
         list
             The input list of vertices sorted in a counter clockwise fashion
         
         """
+        
         return list(reversed(Vertex.CounterClockwise2D(vertices)))
     
     @staticmethod
@@ -414,14 +415,14 @@ class Vertex():
         Sorts the input list of vertices in a counterclockwise fashion. This method assumes that the vertices are on the XY plane. The Z coordinate is ignored.
 
         Parameters
-        -----------
+        ----------
         vertices : list
             The input list of vertices
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
-        Return
-        -----------
+        Returns
+        -------
         list
             The input list of vertices sorted in a counter clockwise fashion
         
@@ -1133,16 +1134,16 @@ class Vertex():
         """
         Returns True if the input vertex is peripheral to the input topology. Returns False otherwise.
         A vertex is said to be peripheral to the input topology if:
-            01. Vertex: If it is internal to it (i.e. coincident with it).
-            02. Edge: If it is internal to its start or end vertices.
-            03. Manifold open wire: If it is internal to its start or end vertices.
-            04. Manifold closed wire: If it is internal to any of its vertices.
-            05. Non-manifold wire: If it is internal to any of its vertices that has a vertex degree of 1.
-            06. Face: If it is internal to any of its edges or vertices.
-            07. Shell: If it is internal to external boundary
-            08. Cell: If it is internal to any of its faces, edges, or vertices.
-            09. CellComplex: If it is peripheral to its external boundary.
-            10. Cluster: If it is peripheral to any of its free topologies. (See Cluster.FreeTopologies)
+        01. Vertex: If it is internal to it (i.e. coincident with it).
+        02. Edge: If it is internal to its start or end vertices.
+        03. Manifold open wire: If it is internal to its start or end vertices.
+        04. Manifold closed wire: If it is internal to any of its vertices.
+        05. Non-manifold wire: If it is internal to any of its vertices that has a vertex degree of 1.
+        06. Face: If it is internal to any of its edges or vertices.
+        07. Shell: If it is internal to external boundary
+        08. Cell: If it is internal to any of its faces, edges, or vertices.
+        09. CellComplex: If it is peripheral to its external boundary.
+        10. Cluster: If it is peripheral to any of its free topologies. (See Cluster.FreeTopologies)
 
         Parameters
         ----------
@@ -1393,10 +1394,10 @@ class Vertex():
         Returns a vertex with coordinates (0, 0, 0)
 
         Parameters
-        -----------
+        ----------
 
-        Return
-        -----------
+        Returns
+        -------
         topologic_core.Vertex
         """
         return Vertex.ByCoordinates(0, 0, 0)
@@ -1525,14 +1526,14 @@ class Vertex():
         Returns the equation of the average plane passing through a list of vertices.
 
         Parameters
-        -----------
+        ----------
         vertices : list
             The input list of vertices
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
 
-        Return
-        -----------
+        Returns
+        -------
         dict
             The dictionary containing the values of a, b, c, d for the plane equation in the form of ax+by+cz+d=0.
             The keys in the dictionary are ["a", "b", "c". "d"]
@@ -1576,7 +1577,7 @@ class Vertex():
         Creates a point (vertex) using the input parameters
 
         Parameters
-        -----------
+        ----------
         x : float , optional.
             The desired x coordinate. The default is 0.
         y : float , optional.
@@ -1584,8 +1585,8 @@ class Vertex():
         z : float , optional.
             The desired z coordinate. The default is 0.
 
-        Return
-        -----------
+        Returns
+        -------
         topologic_core.Vertex
         """
         

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.47'
+__version__ = '0.7.49'

{topologicpy-0.7.47.dist-info → topologicpy-0.7.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.47
+Version: 0.7.49
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License

{topologicpy-0.7.47.dist-info → topologicpy-0.7.49.dist-info}/RECORD

@@ -1,6 +1,6 @@
 topologicpy/ANN.py,sha256=XAuUjNvDRK1hhXfo82S-zXmnAPZGEdHJMRdfpu0aJ8I,47901
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
-topologicpy/Cell.py,sha256=ITQ9EdWEGNKW57EJTewmIhlgk8hk8McM8ZA5oDmubMk,105866
+topologicpy/Cell.py,sha256=uZ1gNVlfVtpi6sNgyfazP_nqe7mPjarE7MYzf8KoEI4,107930
 topologicpy/CellComplex.py,sha256=x474N-lo1krpdIGrWRAFRdDup5a_1V-mLORTS6ZGZ7M,48227
 topologicpy/Cluster.py,sha256=TZXuxzdaUr6OHSWnjWpjCOMlVj6YHBH8aUVbDVsncVA,54999
 topologicpy/Color.py,sha256=UlmRcCSOhqcM_OyMWz4t3Kr75KcgXDhz3uctAJ2n7Ic,18031
@@ -18,18 +18,18 @@ topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=YvtF7RYUMATEZ8iHwFwK_MOxEDyARby2DTI2CCK6-cI,19694
 topologicpy/Plotly.py,sha256=o0JWE51lViK-UJUpIpf2Yusk_vTX5hfNMyFXFinKSRg,106048
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
-topologicpy/PyG.py,sha256=0yeECsMz-dqhhZSv52s_xPCO_3BcEXUK7z1YFDN9qoo,106987
-topologicpy/Shell.py,sha256=aKdWIAqmLKPyi80f2PtH3_1iMfQRW0Eklbqol9cOPWM,87601
+topologicpy/PyG.py,sha256=3U59QObO56EBwrvaplGeLZhbTao0gJCYhWm3oTpjFAE,109505
+topologicpy/Shell.py,sha256=joahFtpRQTWJpQOmi3qU4Xe0Sx2XXeayHlXTNx8CzMk,87610
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
-topologicpy/Sun.py,sha256=InnKtX8eKwtAgcScuABH6yp0ljmWh5m_fDR4-n3jJMY,36869
-topologicpy/Topology.py,sha256=XyXMuw1jTFdHJbuYNub_ngr9mFHmKxejUR7fe6denlk,366314
+topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
+topologicpy/Topology.py,sha256=j_1vCdrOMRi525lqFn63hIJYuD3ZQ8AhHiB8vIiz0zU,379524
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
-topologicpy/Vertex.py,sha256=EQdVYHmW85_pZdHZB3N8pEi0GiadCCkF3z_oqohA7B0,71161
+topologicpy/Vertex.py,sha256=bLY60YWoMsgCgHk7F7k9F93Sq2FJ6AzUcTfJ83NZfHA,71107
 topologicpy/Wire.py,sha256=9EJE0Iq3nGz5X7Suy6xxjmuOpfV49By6WH98UAL_7m4,153532
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=dUV7gU4tNxCy2pDr--lKpOV5DarADBM2ESg5M5mYK6w,23
-topologicpy-0.7.47.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.47.dist-info/METADATA,sha256=6U-VIKu7gA3coK8iB1LazrQeGV8Wkj-q5Fpf4B9ppM0,10918
-topologicpy-0.7.47.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-topologicpy-0.7.47.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.47.dist-info/RECORD,,
+topologicpy/version.py,sha256=hRb_Cf1UnQBFBHqRUC49s9X_xlGuyOLU_zTL7Xm-1Oc,23
+topologicpy-0.7.49.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.49.dist-info/METADATA,sha256=yp1EQDMypWHv6U5kmf0R7RFA8gAc9eX2fxfHqKA7FHw,10918
+topologicpy-0.7.49.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+topologicpy-0.7.49.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.49.dist-info/RECORD,,