topologicpy 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

topologicpy/Cell.py

@@ -2352,6 +2352,128 @@ class Cell():
             volume = None
         return volume
 
+    @staticmethod
+    def Wedge(origin=None,
+            width=1,
+            length=1,
+            height=1,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates a Wedge.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the Wedge. The default is None which results in the Wedge being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the Wedge. The default is 1.0.
+        length : float , optional
+            The overall length of the Wedge. The default is 1.0.
+        height : float , optional
+            The overall height of the Wedge. The default is 1.0.
+        direction : list , optional
+            The vector representing the up direction of the Wedge. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the Wedge. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        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 Wedge.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Cell.Wedge - Error: The width input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(length, int) and not isinstance(length, float):
+            if not silent:
+                print("Cell.Wedge - Error: The length input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(height, int) and not isinstance(height, float):
+            if not silent:
+                print("Cell.Wedge - Error: The height input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Cell.Wedge - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if length <= tolerance:
+            if not silent:
+                print("Cell.Wedge - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+            return None
+        if height <= tolerance:
+            if not silent:
+                print("Cell.Wedge - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Cell.Wedge - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
+            return None
+        if not isinstance(direction, list):
+            if not silent:
+                print("Cell.Wedge - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Cell.Wedge - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        
+        # Define the vertices of the T-shape (counterclockwise)
+        v1 = Vertex.ByCoordinates(0,0,0)
+        v2 = Vertex.ByCoordinates(width, 0, 0)
+        v3 = Vertex.ByCoordinates(width, length, 0)
+        v4 = Vertex.ByCoordinates(0, length, 0)
+        v5 = Vertex.ByCoordinates(0, length, height)
+        v6 = Vertex.ByCoordinates(0, 0, height)
+
+        f1 = Face.ByVertices([v1, v2, v3, v4], tolerance=tolerance)
+        f2 = Face.ByVertices([v1, v2, v6], tolerance=tolerance)
+        f3 = Face.ByVertices([v4, v5, v3], tolerance=tolerance)
+        f4 = Face.ByVertices([v1, v6, v5, v4], tolerance=tolerance)
+        f5 = Face.ByVertices([v2, v3, v5, v6], tolerance=tolerance)
+        cell = Cell.ByFaces([f1, f2, f3, f4, f5])
+        cell = Topology.Translate(cell, -width/2, -length/2, -height/2)
+        cell = Topology.Translate(cell, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
+        if flipHorizontal == True:
+            xScale = -1
+        else:
+            xScale = 1
+        if flipVertical == True:
+            zScale = -1
+        else:
+            zScale = 1
+        if xScale == -1 or zScale == -1:
+            cell = Topology.Scale(cell, origin=origin, x=xScale, y=1, z=zScale)
+        if placement.lower() == "lowerleft":
+            cell = Topology.Translate(cell, origin=origin, x=width/2, y=length/2, z=height/2)
+        elif placement.lower() == "upperright":
+            cell = Topology.Translate(cell, origin=origin, x=-width/2, y=-length/2, z=-height/2)
+        elif placement.lower() == "upperleft":
+            cell = Topology.Translate(cell, origin=origin, x=width/2, y=-length/2, z=-height/2)
+        elif placement.lower() == "lowerright":
+            cell = Topology.Translate(cell, origin=origin, x=-width/2, y=length/2, z=height/2)
+        
+        if direction != [0, 0, 1]:
+            cell = Topology.Orient(cell, origin=origin, dirA=[0, 0, 1], dirB=direction)
+        
+        return cell
+
     @staticmethod
     def Wires(cell) -> list:
         """

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):
@@ -8789,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.
 
@@ -8815,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/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/Vertex.py

@@ -35,7 +35,7 @@ except:
 
 class Vertex():
     @staticmethod
-    def AlignCoordinates(vertex, xList=None, yList=None, zList=None, transferDictionary=False, mantissa=6, silent=False):
+    def AlignCoordinates(vertex, xList: list = None, yList: list = None, zList: list = None, xEpsilon: float = 0.0001, yEpsilon: float = 0.0001, zEpsilon: float = 0.0001, transferDictionary: bool = False, mantissa: int = 6, silent: bool = False):
         """
             Aligns the coordinates of the input vertex with the list of x,y, and z coordinates.
 
@@ -49,6 +49,12 @@ class Vertex():
                 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.
+            xEpsilon : float , optional
+                The desired tolerance for the x coordinates. The default is 0.0001.
+            yEpsilon : float , optional
+                The desired tolerance for the y coordinates. The default is 0.0001. 
+            zEpsilon : float , optional
+                The desired tolerance for the z coordinates. The default is 0.0001. 
             transferDictionary : bool , optional
                 if set to True, the dictionary of the input vertex is transferred to the new vertex.
             mantissa : int , optional
@@ -70,17 +76,24 @@ class Vertex():
                 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)
+        x, y, z = Vertex.Coordinates(vertex, mantissa=mantissa)
         if isinstance(xList, list):
             if len(xList) > 0:
-                closest_x = xList[Helper.ClosestMatch(closest_x, xList)]
+                closest_x = round(xList[Helper.ClosestMatch(x, xList)], mantissa)
         if isinstance(yList, list):
             if len(yList) > 0:
-                closest_y = yList[Helper.ClosestMatch(closest_y, yList)]
+                closest_y = round(yList[Helper.ClosestMatch(y, yList)], mantissa)
         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)
+                closest_z = round(zList[Helper.ClosestMatch(z, zList)], mantissa)
+        
+        if abs(x - closest_x) < xEpsilon:
+            x = closest_x
+        if abs(y - closest_y) < yEpsilon:
+            y = closest_y
+        if abs(z - closest_z) < zEpsilon:
+            z = closest_z
+        return_vertex = Vertex.ByCoordinates(x, y, z)
         if transferDictionary == True:
             return_vertex = Topology.SetDictionary(return_vertex, Topology.Dictionary(vertex), silent=silent)
         return return_vertex

topologicpy/Wire.py

@@ -51,7 +51,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
         import numpy as np
 
@@ -183,7 +182,6 @@ class Wire():
 
         """
         from topologicpy.Edge import Edge
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(edge, "Edge"):
@@ -233,7 +231,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -453,7 +450,6 @@ class Wire():
         from topologicpy.Edge import Edge
         from topologicpy.Face import Face
         from topologicpy.Dictionary import Dictionary
-        from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
@@ -724,7 +720,6 @@ class Wire():
             The created wire.
 
         """
-        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -1472,7 +1467,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -1595,7 +1589,7 @@ class Wire():
         else:
             yScale = 1
         if xScale == -1 or yScale == -1:
-            cross_shape = Topology.Scale(cross_shape, x=xScale, y=yScale, z=1)
+            cross_shape = Topology.Scale(cross_shape, origin=origin, x=xScale, y=yScale, z=1)
             if reverse == True:
                 cross_shape = Wire.Reverse(cross_shape)
         if placement.lower() == "lowerleft":
@@ -1657,7 +1651,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -1745,7 +1738,7 @@ class Wire():
         else:
             yScale = 1
         if xScale == -1 or yScale == -1:
-            c_shape = Topology.Scale(c_shape, x=xScale, y=yScale, z=1)
+            c_shape = Topology.Scale(c_shape, origin=origin, x=xScale, y=yScale, z=1)
             if reverse == True:
                 c_shape = Wire.Reverse(c_shape)
         if placement.lower() == "lowerleft":
@@ -2287,7 +2280,6 @@ class Wire():
         import math
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
-        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
@@ -2777,7 +2769,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -2869,7 +2860,7 @@ class Wire():
         else:
             yScale = 1
         if xScale == -1 or yScale == -1:
-            i_shape = Topology.Scale(i_shape, x=xScale, y=yScale, z=1)
+            i_shape = Topology.Scale(i_shape, origin=origin, x=xScale, y=yScale, z=1)
             if reverse == True:
                 i_shape = Wire.Reverse(i_shape)
         if placement.lower() == "lowerleft":
@@ -3024,7 +3015,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -3106,7 +3096,7 @@ class Wire():
         else:
             yScale = 1
         if xScale == -1 or yScale == -1:
-            l_shape = Topology.Scale(l_shape, x=xScale, y=yScale, z=1)
+            l_shape = Topology.Scale(l_shape, origin=origing, x=xScale, y=yScale, z=1)
             if reverse == True:
                 l_shape = Wire.Reverse(l_shape)
         if placement.lower() == "lowerleft":
@@ -3163,9 +3153,7 @@ class Wire():
         import math
         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.Topology import Topology
         from topologicpy.Vector import Vector
         from topologicpy.Dictionary import Dictionary
@@ -3632,7 +3620,6 @@ class Wire():
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
-        from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
 
@@ -3727,7 +3714,6 @@ class Wire():
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
-        from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         import inspect
@@ -4537,7 +4523,6 @@ class Wire():
             return x*radius, y*radius
         
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
         
         if not Topology.IsInstance(origin, "Vertex"):
@@ -4788,7 +4773,6 @@ class Wire():
             baseWire = Topology.Orient(baseWire, origin=origin, dirA=[0, 0, 1], dirB=direction)
         return baseWire
 
-
     @staticmethod
     def TShape(origin=None,
             width=1,
@@ -4832,7 +4816,6 @@ class Wire():
 
         """
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
         if not isinstance(width, int) and not isinstance(width, float):
@@ -4916,7 +4899,7 @@ class Wire():
         else:
             yScale = 1
         if xScale == -1 or yScale == -1:
-            t_shape = Topology.Scale(t_shape, x=xScale, y=yScale, z=1)
+            t_shape = Topology.Scale(t_shape, origin=origin, x=xScale, y=yScale, z=1)
             if reverse == True:
                 t_shape = Wire.Reverse(t_shape)
         if placement.lower() == "lowerleft":

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.7'
+__version__ = '0.8.9'

{topologicpy-0.8.7.dist-info → topologicpy-0.8.9.dist-info}/METADATA

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

@@ -1,7 +1,7 @@
 topologicpy/ANN.py,sha256=m_WxD1lgQqDhUpaM20Lia6TmJACDYaAE96wigsi-99U,47932
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/BVH.py,sha256=mKVCAu9K8qzcWXtPDVH5usXZV1DNNNJl4n3rU5Lh1ZM,12931
-topologicpy/Cell.py,sha256=o5CxsBXxtnV439I4f8VMUoDMVwO5o3q0lHinHHMSmFg,108571
+topologicpy/Cell.py,sha256=9bF1pS0oyYmUzyXZ4zAQrwJPrQ7KeHRAo8OZudp_2Kg,114341
 topologicpy/CellComplex.py,sha256=-s8RKGa2H1eqLO7g6qyQvvuFMFJ0aIgXvIr9kOVgpjA,51608
 topologicpy/Cluster.py,sha256=o5jdMRpcGfSGGiXQdFg-e9XcnBF5AqTj3xb1nSpwJWE,58606
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
@@ -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=rq7QGgb2eTJucFT6YeQujs1zoZg-KHMvHOWPjG1btG4,492418
+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
@@ -24,13 +24,13 @@ topologicpy/Shell.py,sha256=fLRnQ79vtdBDRW1Xn8Gaap34XheGbw7UBFd-ALJ2Y1g,87978
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
 topologicpy/Topology.py,sha256=qw64d3Ct6u7W8Fy_-JIg3_xsyOzDIQ1hdnpxF2p_wH4,463931
-topologicpy/Vector.py,sha256=Cl7besf20cAGmyNPh-9gbFAHnRU5ZWSMChJ3VyFIDs4,35416
-topologicpy/Vertex.py,sha256=tv6C-rbuNgXHDGgVLT5fbalynLdXqlUuiCDKtkeQ0vk,77814
-topologicpy/Wire.py,sha256=Gl3Jpygwp8775SG57ua5r5ffTHcN4FOAkeI87yP1cok,234001
+topologicpy/Vector.py,sha256=3gW0Y7mTcpc6ctjSfRWQXGKjIyHASKrMyIyPDT0kO2E,39573
+topologicpy/Vertex.py,sha256=8_7iGDPlNWsiNfxcuNRO5u7P07i1Y58Gprw7KtA2Wmw,78505
+topologicpy/Wire.py,sha256=Pt2li4cZ1omQKcMDCOqdB01ZKqjA4KBR0K3lGNVUoDs,233398
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=JGCf_Ym2Ht0sZ3u8dNB1-xTLbDj-N0D-i99vGQQMfWs,22
-topologicpy-0.8.7.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.7.dist-info/METADATA,sha256=uDBR73QF2TnGhpaMNI-vIBGeZTF-c7IMM5DI7AxwzEI,10512
-topologicpy-0.8.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.7.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.7.dist-info/RECORD,,
+topologicpy/version.py,sha256=NlRwwFdz-gLvpPJ1P15liW62rdqtILNRJEm3y_yv3z8,22
+topologicpy-0.8.9.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.9.dist-info/METADATA,sha256=cFgD49CaDIZRj1a8FDEMkyw2dINg6WQZxTqbp55p--4,10512
+topologicpy-0.8.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+topologicpy-0.8.9.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.9.dist-info/RECORD,,