topologicpy 0.8.5__py3-none-any.whl → 0.8.8__py3-none-any.whl

topologicpy/Graph.py

@@ -264,6 +264,164 @@ class _DrawTree(object):
         return self.__str__()
 
 class Graph:
+    @staticmethod
+    def AddEdge(graph, edge, transferVertexDictionaries: bool = False, transferEdgeDictionaries: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds the input edge to the input Graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        edge : topologic_core.Edge
+            The input edge.
+        transferVertexDictionaries : bool, optional
+            If set to True, the dictionaries of the vertices are transferred to the graph.
+        transferEdgeDictionaries : bool, optional
+            If set to True, the dictionaries of the edges are transferred to the graph.
+        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.Graph
+            The input graph with the input edge added to it.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+
+        def addIfUnique(graph_vertices, vertex, tolerance=0.0001):
+            unique = True
+            returnVertex = vertex
+            for gv in graph_vertices:
+                if (Vertex.Distance(vertex, gv) < tolerance):
+                    if transferVertexDictionaries == True:
+                        gd = Topology.Dictionary(gv)
+                        vd = Topology.Dictionary(vertex)
+                        gk = gd.Keys()
+                        vk = vd.Keys()
+                        d = None
+                        if (len(gk) > 0) and (len(vk) > 0):
+                            d = Dictionary.ByMergedDictionaries([gd, vd])
+                        elif (len(gk) > 0) and (len(vk) < 1):
+                            d = gd
+                        elif (len(gk) < 1) and (len(vk) > 0):
+                            d = vd
+                        if d:
+                            _ = Topology.SetDictionary(gv, d, silent=True)
+                    unique = False
+                    returnVertex = gv
+                    break
+            if unique:
+                graph_vertices.append(vertex)
+            return [graph_vertices, returnVertex]
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.AddEdge - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(edge, "Edge"):
+            if not silent:
+                print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning the input graph.")
+            return graph
+        graph_vertices = Graph.Vertices(graph)
+        graph_edges = Graph.Edges(graph, graph_vertices, tolerance=tolerance)
+        vertices = Topology.Vertices(edge)
+        new_vertices = []
+        for vertex in vertices:
+            graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance=tolerance)
+            new_vertices.append(nv)
+        new_edge = Edge.ByVertices([new_vertices[0], new_vertices[1]], tolerance=tolerance)
+        if transferEdgeDictionaries == True:
+            d = Topology.Dictionary(edge)
+            keys = Dictionary.Keys(d)
+            if isinstance(keys, list):
+                if len(keys) > 0:
+                    _ = Topology.SetDictionary(new_edge, d, silent=True)
+        graph_edges.append(new_edge)
+        new_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
+        return new_graph
+    
+    @staticmethod
+    def AddVertex(graph, vertex, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds the input vertex to the input graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertex : topologic_core.Vertex
+            The input vertex.
+        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.Graph
+            The input graph with the input vertex added to it.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.AddVertex - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(vertex, "Vertex"):
+            if not silent:
+                print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning the input graph.")
+            return graph
+        _ = graph.AddVertices([vertex], tolerance) # Hook to Core
+        return graph
+
+    @staticmethod
+    def AddVertices(graph, vertices, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Adds the input vertex to the input graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertices : list
+            The input list of vertices.
+        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.Graph
+            The input graph with the input vertex added to it.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.AddVertices - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertices, list):
+            if not silent:
+                print("Graph.AddVertices - Error: The input list of vertices is not a valid list. Returning None.")
+            return None
+        vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+        if len(vertices) < 1:
+            if not silent:
+                print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
+            return None
+        _ = graph.AddVertices(vertices, tolerance) # Hook to Core
+        return graph
+    
     def AdjacencyDictionary(graph, vertexLabelKey: str = None, edgeKey: str = "Length", includeWeights: bool = False, reverse: bool = False, mantissa: int = 6):
         """
         Returns the adjacency dictionary of the input Graph.
@@ -517,167 +675,101 @@ class Graph:
         return adjList
 
     @staticmethod
-    def AddEdge(graph, edge, transferVertexDictionaries: bool = False, transferEdgeDictionaries: bool = False, tolerance: float = 0.0001, silent: bool = False):
+    def AdjacentVertices(graph, vertex, silent: bool = False):
         """
-        Adds the input edge to the input Graph.
+        Returns the list of vertices connected to the input vertex.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
-        edge : topologic_core.Edge
-            The input edge.
-        transferVertexDictionaries : bool, optional
-            If set to True, the dictionaries of the vertices are transferred to the graph.
-        transferEdgeDictionaries : bool, optional
-            If set to True, the dictionaries of the edges are transferred to the graph.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
+        vertex : topologic_core.Vertex
+            the input vertex.
         silent : bool , optional
             If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
-        topologic_core.Graph
-            The input graph with the input edge added to it.
+        list
+            The list of adjacent vertices.
 
         """
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Edge import Edge
-        from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
-        def addIfUnique(graph_vertices, vertex, tolerance=0.0001):
-            unique = True
-            returnVertex = vertex
-            for gv in graph_vertices:
-                if (Vertex.Distance(vertex, gv) < tolerance):
-                    if transferVertexDictionaries == True:
-                        gd = Topology.Dictionary(gv)
-                        vd = Topology.Dictionary(vertex)
-                        gk = gd.Keys()
-                        vk = vd.Keys()
-                        d = None
-                        if (len(gk) > 0) and (len(vk) > 0):
-                            d = Dictionary.ByMergedDictionaries([gd, vd])
-                        elif (len(gk) > 0) and (len(vk) < 1):
-                            d = gd
-                        elif (len(gk) < 1) and (len(vk) > 0):
-                            d = vd
-                        if d:
-                            _ = Topology.SetDictionary(gv, d, silent=True)
-                    unique = False
-                    returnVertex = gv
-                    break
-            if unique:
-                graph_vertices.append(vertex)
-            return [graph_vertices, returnVertex]
-
         if not Topology.IsInstance(graph, "Graph"):
             if not silent:
-                print("Graph.AddEdge - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVertices - Error: The input graph is not a valid graph. Returning None.")
             return None
-        if not Topology.IsInstance(edge, "Edge"):
+        if not Topology.IsInstance(vertex, "Vertex"):
             if not silent:
-                print("Graph.AddEdge - Error: The input edge is not a valid edge. Returning the input graph.")
-            return graph
-        graph_vertices = Graph.Vertices(graph)
-        graph_edges = Graph.Edges(graph, graph_vertices, tolerance=tolerance)
-        vertices = Topology.Vertices(edge)
-        new_vertices = []
-        for vertex in vertices:
-            graph_vertices, nv = addIfUnique(graph_vertices, vertex, tolerance=tolerance)
-            new_vertices.append(nv)
-        new_edge = Edge.ByVertices([new_vertices[0], new_vertices[1]], tolerance=tolerance)
-        if transferEdgeDictionaries == True:
-            d = Topology.Dictionary(edge)
-            keys = Dictionary.Keys(d)
-            if isinstance(keys, list):
-                if len(keys) > 0:
-                    _ = Topology.SetDictionary(new_edge, d, silent=True)
-        graph_edges.append(new_edge)
-        new_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
-        return new_graph
+                print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
+            return None
+        vertices = []
+        _ = graph.AdjacentVertices(vertex, vertices) # Hook to Core
+        return list(vertices)
     
     @staticmethod
-    def AddVertex(graph, vertex, tolerance: float = 0.0001, silent: bool = False):
+    def AdjacentVerticesByCompassDirection(graph, vertex, compassDirection: str = "Up", tolerance: float = 0.0001, silent: bool = False):
         """
-        Adds the input vertex to the input graph.
+        Returns the list of vertices connected to the input vertex that are in the input compass direction.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
         vertex : topologic_core.Vertex
-            The input vertex.
+            the input vertex.
+        compassDirection : str , optional
+            The compass direction. See Vector.CompassDirections(). The default is "Up".
         tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
+                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.Graph
-            The input graph with the input vertex added to it.
+        list
+            The list of adjacent vertices that are in the compass direction.
 
         """
+        from topologicpy.Vector import Vector
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(graph, "Graph"):
+        
+        if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.AddVertex - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input graph parameter is not a valid graph. Returning None.")
             return None
-        if not Topology.IsInstance(vertex, "Vertex"):
+        if not Topology.IsInstance(vertex, "vertex"):
             if not silent:
-                print("Graph.AddVertex - Error: The input vertex is not a valid vertex. Returning the input graph.")
-            return graph
-        _ = graph.AddVertices([vertex], tolerance) # Hook to Core
-        return graph
-
-    @staticmethod
-    def AddVertices(graph, vertices, tolerance: float = 0.0001, silent: bool = False):
-        """
-        Adds the input vertex to the input graph.
-
-        Parameters
-        ----------
-        graph : topologic_core.Graph
-            The input graph.
-        vertices : list
-            The input list of vertices.
-        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.Graph
-            The input graph with the input vertex added to it.
-
-        """
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(graph, "Graph"):
-            if not silent:
-                print("Graph.AddVertices - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input vertex parameter is not a valid vertex. Returning None.")
             return None
-        if not isinstance(vertices, list):
+        if not isinstance(compassDirection, str):
             if not silent:
-                print("Graph.AddVertices - Error: The input list of vertices is not a valid list. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input compassDirection parameter is not a valid string. Returning None.")
             return None
-        vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
-        if len(vertices) < 1:
+        
+        directions = [v.lower() for v in Vector.CompassDirections()]
+
+        if not compassDirection.lower() in directions:
             if not silent:
-                print("Graph.AddVertices - Error: Could not find any valid vertices in the input list of vertices. Returning None.")
+                print("Graph.AdjacentVerticesByCompassDirection - Error: The input compassDirection parameter is not a valid compass direction. Returning None.")
             return None
-        _ = graph.AddVertices(vertices, tolerance) # Hook to Core
-        return graph
-    
+
+        adjacent_vertices = Graph.AdjacentVertices(graph, vertex)
+        return_vertices = []
+        for v in adjacent_vertices:
+            e = Edge.ByVertices(vertex, v)
+            vector = Edge.Direction(e)
+            compass_direction = Vector.CompassDirection(vector, tolerance=tolerance)
+            if compass_direction.lower() == compassDirection.lower():
+                return_vertices.append(v)
+        return return_vertices
+
     @staticmethod
-    def AdjacentVertices(graph, vertex, silent: bool = False):
+    def AdjacentVerticesByVector(graph, vertex, vector: list = [0,0,1], tolerance: float = 0.0001, silent: bool = False):
         """
-        Returns the list of vertices connected to the input vertex.
+        Returns the list of vertices connected to the input vertex that are in the input vector direction.
 
         Parameters
         ----------
@@ -685,28 +777,48 @@ class Graph:
             The input graph.
         vertex : topologic_core.Vertex
             the input vertex.
+        vector : list , optional
+            The vector direction. The default is [0,0,1].
+        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
-            The list of adjacent vertices.
+            The list of adjacent vertices that are in the vector direction.
 
         """
+        from topologicpy.Vector import Vector
+        from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(graph, "Graph"):
+        
+        if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.AdjacentVertices - Error: The input graph is not a valid graph. Returning None.")
+                print("Graph.AdjacentVerticesByVector- Error: The input graph parameter is not a valid graph. Returning None.")
             return None
-        if not Topology.IsInstance(vertex, "Vertex"):
+        if not Topology.IsInstance(vertex, "vertex"):
             if not silent:
-                print("Graph.AdjacentVertices - Error: The input vertex is not a valid vertex. Returning None.")
+                print("Graph.AdjacentVerticesByVector- Error: The input vertex parameter is not a valid vertex. Returning None.")
             return None
-        vertices = []
-        _ = graph.AdjacentVertices(vertex, vertices) # Hook to Core
-        return list(vertices)
+        if not isinstance(vector, list):
+            if not silent:
+                print("Graph.AdjacentVerticesByVector- Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+        if len(vector) != 3:
+            if not silent:
+                print("Graph.AdjacentVerticesByVector- Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+
+        adjacent_vertices = Graph.AdjacentVertices(graph, vertex)
+        return_vertices = []
+        for v in adjacent_vertices:
+            e = Edge.ByVertices(vertex, v)
+            edge_vector = Edge.Direction(e)
+            if Vector.CompassDirection(vector, tolerance=tolerance).lower() == Vector.CompassDirection(edge_vector, tolerance=tolerance).lower():
+                return_vertices.append(v)
+        return return_vertices
     
     @staticmethod
     def AllPaths(graph, vertexA, vertexB, timeLimit=10, silent: bool = False):
@@ -2624,6 +2736,10 @@ class Graph:
                 # Store relevant information
                 if transferDictionaries == True:
                     color, transparency, material_list = get_color_transparency_material(ifc_object)
+                    if color == None:
+                        color = "white"
+                    if transparency == None:
+                        transparency = 0
                     entity_dict = {
                         "TOPOLOGIC_id": str(Topology.UUID(centroid)),
                         "TOPOLOGIC_name": getattr(ifc_object, 'Name', "Untitled"),
@@ -2645,19 +2761,22 @@ class Graph:
                         if hasattr(ifc_object, "Representation") and ifc_object.Representation:
                             for rep in ifc_object.Representation.Representations:
                                 if rep.is_a("IfcShapeRepresentation"):
-                                    # Generate the geometry for this entity
-                                    shape = ifcopenshell.geom.create_shape(settings, ifc_object)
-                                    # Get grouped vertices and grouped faces     
-                                    grouped_verts = shape.geometry.verts
-                                    verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
-                                    grouped_edges = shape.geometry.edges
-                                    edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
-                                    grouped_faces = shape.geometry.faces
-                                    faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
-                                    shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
-                                    if not shape_topology == None:
-                                        if removeCoplanarFaces == True:
-                                            shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+                                    try:
+                                        # Generate the geometry for this entity
+                                        shape = ifcopenshell.geom.create_shape(settings, ifc_object)
+                                        # Get grouped vertices and grouped faces     
+                                        grouped_verts = shape.geometry.verts
+                                        verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
+                                        grouped_edges = shape.geometry.edges
+                                        edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
+                                        grouped_faces = shape.geometry.faces
+                                        faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
+                                        shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
+                                        if not shape_topology == None:
+                                            if removeCoplanarFaces == True:
+                                                shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+                                    except:
+                                        pass
                         if not shape_topology == None and storeBREP:
                             topology_dict = Dictionary.SetValuesAtKeys(topology_dict, ["brep", "brepType", "brepTypeString"], [Topology.BREPString(shape_topology), Topology.Type(shape_topology), Topology.TypeAsString(shape_topology)])
                         if not shape_topology == None and useInternalVertex == True:
@@ -8782,7 +8901,7 @@ class Graph:
         return max_flow
 
     @staticmethod
-    def MeshData(g, tolerance: float = 0.0001):
+    def MeshData(graph, tolerance: float = 0.0001):
         """
         Returns the mesh data of the input graph.
 
@@ -8808,14 +8927,14 @@ class Graph:
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
-        g_vertices = Graph.Vertices(g)
+        g_vertices = Graph.Vertices(graph)
         m_vertices = []
         v_dicts = []
         for g_vertex in g_vertices:
             m_vertices.append(Vertex.Coordinates(g_vertex))
             d = Dictionary.PythonDictionary(Topology.Dictionary(g_vertex))
             v_dicts.append(d)
-        g_edges = Graph.Edges(g)
+        g_edges = Graph.Edges(graph)
         m_edges = []
         e_dicts = []
         for g_edge in g_edges:

topologicpy/Topology.py

@@ -2515,50 +2515,55 @@ class Topology():
         def convert_to_topology(entity, settings, transferDictionaries=False):    
             if hasattr(entity, "Representation") and entity.Representation:
                 for rep in entity.Representation.Representations:
+                    shape_topology = None
                     if rep.is_a("IfcShapeRepresentation"):
                         # Generate the geometry for this entity
-                        shape = ifcopenshell.geom.create_shape(settings, entity)
                         try:
+                            shape = ifcopenshell.geom.create_shape(settings, entity)
                             trans = shape.transformation
                             # Convert into a 4x4 matrix
                             matrix = [trans.matrix[i:i+4] for i in range(0, len(trans.matrix), 4)]
+                            # Get grouped vertices and grouped faces     
+                            grouped_verts = shape.geometry.verts
+                            verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
+                            grouped_edges = shape.geometry.edges
+                            edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
+                            grouped_faces = shape.geometry.faces
+                            faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
+                            #shape_topology = ifc_to_topologic_geometry(verts, edges, faces)
+                            #shape_topology = Topology.SelfMerge(Topology.ByGeometry(verts, edges, faces))
+                            shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
+                            if not shape_topology == None:
+                                if removeCoplanarFaces == True:
+                                    shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+                                shape_topology = Topology.Transform(shape_topology, matrix)
+
+                                # Store relevant information
+                                if transferDictionaries == True:
+                                    color, transparency, material_list = get_color_transparency_material(entity)
+                                    if color == None:
+                                        color = "white"
+                                    if transparency == None:
+                                        transparency = 0
+                                    entity_dict = {
+                                        "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
+                                        "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
+                                        "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
+                                        "TOPOLOGIC_color": color,
+                                        "TOPOLOGIC_opacity": 1.0 - transparency,
+                                        "IFC_global_id": getattr(entity, 'GlobalId', 0),
+                                        "IFC_name": getattr(entity, 'Name', "Untitled"),
+                                        "IFC_type": entity.is_a(),
+                                        "IFC_material_list": material_list,
+                                    }
+                                    topology_dict = Dictionary.ByPythonDictionary(entity_dict)
+                                    # Get PSETs dictionary
+                                    pset_python_dict = get_psets(entity)
+                                    pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
+                                    topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
+                                    shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
                         except:
                             pass
-                        # Get grouped vertices and grouped faces     
-                        grouped_verts = shape.geometry.verts
-                        verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
-                        grouped_edges = shape.geometry.edges
-                        edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
-                        grouped_faces = shape.geometry.faces
-                        faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
-                        #shape_topology = ifc_to_topologic_geometry(verts, edges, faces)
-                        #shape_topology = Topology.SelfMerge(Topology.ByGeometry(verts, edges, faces))
-                        shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
-                        if not shape_topology == None:
-                            if removeCoplanarFaces == True:
-                                shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
-                            shape_topology = Topology.Transform(shape_topology, matrix)
-
-                            # Store relevant information
-                            if transferDictionaries == True:
-                                color, transparency, material_list = get_color_transparency_material(entity)
-                                entity_dict = {
-                                    "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
-                                    "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
-                                    "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
-                                    "TOPOLOGIC_color": color,
-                                    "TOPOLOGIC_opacity": 1.0 - transparency,
-                                    "IFC_global_id": getattr(entity, 'GlobalId', 0),
-                                    "IFC_name": getattr(entity, 'Name', "Untitled"),
-                                    "IFC_type": entity.is_a(),
-                                    "IFC_material_list": material_list,
-                                }
-                                topology_dict = Dictionary.ByPythonDictionary(entity_dict)
-                                # Get PSETs dictionary
-                                pset_python_dict = get_psets(entity)
-                                pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
-                                topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
-                                shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
                         return shape_topology
             return None
 

topologicpy/Vector.py

@@ -359,6 +359,120 @@ class Vector(list):
         ang2 = arctan2(*p2[::-1])
         return round(rad2deg((ang1 - ang2) % (2 * pi)), mantissa)
 
+    @staticmethod
+    def CompassDirection(vector, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Returns the compass direction of the input direction.
+        The possible returned values are:
+        - North, East, South, West
+        - Northeast, Southeast, Southwest, Northwest
+        - A combination of the above (e.g. Up_Noertheast)
+        - Up, Down
+        - Origin
+
+        Parameters
+        ----------
+        vector : list
+            The input vector.
+        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
+        -------
+        str
+            The compass direction of the input vector. The possible values are:
+            - North, East, South, West
+            - Northeast, Southeast, Southwest, Northwest
+            - A combination of the above (e.g. Up_Noertheast)
+            - Up, Down
+            - Origin
+
+        """
+        import math
+
+        if not isinstance(vector, list):
+            if not silent:
+                print("Vector.CompassDirection - Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+        if len(vector) != 3:
+            if not silent:
+                print("Vector.CompassDirection - Error: The input vector parameter is not a valid vector. Returning None.")
+            return None
+        
+        x, y, z = vector
+        
+        # Handle the origin
+        if abs(x) < tolerance and abs(y) < tolerance and abs(z) < tolerance:
+            return "Origin"
+        
+        # Normalize vector to prevent magnitude bias
+        magnitude = math.sqrt(x**2 + y**2 + z**2)
+        x, y, z = x / magnitude, y / magnitude, z / magnitude
+        
+        # Apply tolerance to components
+        x = 0 if abs(x) < tolerance else x
+        y = 0 if abs(y) < tolerance else y
+        z = 0 if abs(z) < tolerance else z
+        
+        # Compass-based direction in the XY-plane
+        if x == 0 and y > 0:
+            horizontal_dir = "North"
+        elif x == 0 and y < 0:
+            horizontal_dir = "South"
+        elif y == 0 and x > 0:
+            horizontal_dir = "East"
+        elif y == 0 and x < 0:
+            horizontal_dir = "West"
+        elif x > 0 and y > 0:
+            horizontal_dir = "Northeast"
+        elif x < 0 and y > 0:
+            horizontal_dir = "Northwest"
+        elif x < 0 and y < 0:
+            horizontal_dir = "Southwest"
+        elif x > 0 and y < 0:
+            horizontal_dir = "Southeast"
+        else:
+            horizontal_dir = ""
+        
+        # Add vertical direction
+        if z > 0:
+            if horizontal_dir:
+                return f"Up_{horizontal_dir}"
+            return "Up"
+        elif z < 0:
+            if horizontal_dir:
+                return f"Down_{horizontal_dir}"
+            return "Down"
+        else:
+            return horizontal_dir
+    
+    @staticmethod
+    def CompassDirections():
+        """
+        Returns the list of allowed compass directions.
+
+        Parameters
+        ----------
+
+        Returns
+        -------
+        list
+            The list of compass directions. These are:
+            - ["Origin", "Up", "Down",
+              "North", "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest",
+              "Up_North", "Up_Northeast", "Up_East", "Up_Southeast", "Up_South", "Up_Southwest", "Up_West", "Up_Northwest",
+               "Down_North", "Down_Northeast", "Down_East", "Down_Southeast", "Down_South", "Down_Southwest", "Down_West", "Down_Northwest",
+              ]
+
+        """
+        return ["Origin", "Up", "Down",
+                "North", "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest",
+                "Up_North", "Up_Northeast", "Up_East", "Up_Southeast", "Up_South", "Up_Southwest", "Up_West", "Up_Northwest",
+                "Down_North", "Down_Northeast", "Down_East", "Down_Southeast", "Down_South", "Down_Southwest", "Down_West", "Down_Northwest"
+                ]
+    
     @staticmethod
     def Coordinates(vector, outputType="xyz", mantissa: int = 6, silent: bool = False):
         """

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.5'
+__version__ = '0.8.8'

{topologicpy-0.8.5.dist-info → topologicpy-0.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: topologicpy
-Version: 0.8.5
+Version: 0.8.8
 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.5.dist-info → topologicpy-0.8.8.dist-info}/RECORD

@@ -11,7 +11,7 @@ topologicpy/Dictionary.py,sha256=t0O7Du-iPq46FyKqZfcjHfsUK1E8GS_e67R2V5cpkbw,331
 topologicpy/Edge.py,sha256=lWwJdQkAhiH5POB7TN6HSLv03g2jXHzBU7e2fE3eAno,71340
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=D1g4O5i5QMPZvIoX06Z-FsyNsYBDkCiHWJp00uqnr5o,180742
-topologicpy/Graph.py,sha256=T_NC-Gvf7F7DWdfWvQB7sQ_v790lTT74SLKTl-UhSZE,492072
+topologicpy/Graph.py,sha256=yjD778MyWFLmUEryGFEzFZOJmnrZwkqrVYvpmH76Oxs,497462
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=DAAE_Ie_ekeMnCvcW08xXRwSAGCkjrS4lbz-o3ELuY4,27172
 topologicpy/Honeybee.py,sha256=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
@@ -23,14 +23,14 @@ topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=fLRnQ79vtdBDRW1Xn8Gaap34XheGbw7UBFd-ALJ2Y1g,87978
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=ejgcsZ6KUmQOkJuev102FyqnOSZLuwzupMh1p7g_hCc,463521
-topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
+topologicpy/Topology.py,sha256=qw64d3Ct6u7W8Fy_-JIg3_xsyOzDIQ1hdnpxF2p_wH4,463931
+topologicpy/Vector.py,sha256=3gW0Y7mTcpc6ctjSfRWQXGKjIyHASKrMyIyPDT0kO2E,39573
 topologicpy/Vertex.py,sha256=tv6C-rbuNgXHDGgVLT5fbalynLdXqlUuiCDKtkeQ0vk,77814
 topologicpy/Wire.py,sha256=Gl3Jpygwp8775SG57ua5r5ffTHcN4FOAkeI87yP1cok,234001
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=Vtr3iQMVF7gSX8AO7oEPv4S6HgRTdmjlmLyqQPj32xc,22
-topologicpy-0.8.5.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.5.dist-info/METADATA,sha256=8Dybj0s_HtTlA0VLOLlmuYS3WP0SKyyiU4Evy5RQBrA,10512
-topologicpy-0.8.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.5.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.5.dist-info/RECORD,,
+topologicpy/version.py,sha256=ysM7ZSdOuCpaNFiqoGIRai1zq8iwLDlTTCvJsGJ1_eA,22
+topologicpy-0.8.8.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.8.dist-info/METADATA,sha256=h8t8ZxpBukHW7YQu9muct8f09ZIkb_tZFhP_IPWtc4c,10512
+topologicpy-0.8.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+topologicpy-0.8.8.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.8.dist-info/RECORD,,