topologicpy 0.7.57__py3-none-any.whl → 0.7.60__py3-none-any.whl

topologicpy/BVH.py

@@ -0,0 +1,296 @@
+# Copyright (C) 2024
+# Wassim Jabi <wassim.jabi@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License along with
+# this program. If not, see <https://www.gnu.org/licenses/>.
+
+import topologic_core as topologic
+import warnings
+
+try:
+    import numpy as np
+except:
+    print("BVH - Installing required numpy library.")
+    try:
+        os.system("pip install numpy")
+    except:
+        os.system("pip install numpy --user")
+    try:
+        import numpy as np
+        print("BVH - numpy library installed correctly.")
+    except:
+        warnings.warn("ANN - Error: Could not import numpy.")
+
+class BVH:
+    # A class for Axis-Aligned Bounding Box (AABB)
+    class AABB:
+        def __init__(self, min_point, max_point):
+            self.min_point = np.array(min_point)
+            self.max_point = np.array(max_point)
+            self.centroid = (self.min_point + self.max_point) / 2.0
+
+        def intersects(self, other):
+            # Check if this AABB intersects with another AABB
+            return np.all(self.min_point <= other.max_point) and np.all(self.max_point >= other.min_point)
+
+        def contains(self, point):
+            # Check if a point is contained within the AABB
+            return np.all(self.min_point <= point) and np.all(self.max_point >= point)
+
+    # MeshObject class that stores a reference to the Topologic object
+    class MeshObject:
+        def __init__(self, vertices, topologic_object):
+            self.vertices = np.array(vertices)
+            self.aabb = BVH.AABB(np.min(vertices, axis=0), np.max(vertices, axis=0))
+            self.centroid = np.mean(vertices, axis=0)
+            self.topologic_object = topologic_object  # Store the Topologic object reference
+
+    # BVH Node class
+    class BVHNode:
+        def __init__(self, aabb, left=None, right=None, objects=None):
+            self.aabb = aabb
+            self.left = left
+            self.right = right
+            self.objects = objects if objects else []
+
+    @staticmethod
+    def ByTopologies(*topologies, silent: bool = False):
+        """
+        Creates a BVH Tree from the input list of topologies. The input can be individual topologies each as an input argument or a list of topologies stored in one input argument.
+
+        Parameters
+        ----------
+        topologies : list
+            The list of topologies.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        BVH tree
+            The created BVH tree.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        if len(topologies) == 0:
+            print("BVH.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+            return None
+        if len(topologies) == 1:
+            topologyList = topologies[0]
+            if isinstance(topologyList, list):
+                if len(topologyList) == 0:
+                    if not silent:
+                        print("BVH.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+                    return None
+                else:
+                    topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+                    if len(topologyList) == 0:
+                        if not silent:
+                            print("BVH.ByTopologies - Error: The input topologies parameter does not contain any valid topologies. Returning None.")
+                        return None
+            else:
+                if not silent:
+                    print("BVH.ByTopologies - Warning: The input topologies parameter contains only one topology. Returning the same topology.")
+                return topologies
+        else:
+            topologyList = Helper.Flatten(list(topologies))
+            topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+        if len(topologyList) == 0:
+            if not silent:
+                print("BVH.ByTopologies - Error: The input parameters do not contain any valid topologies. Returning None.")
+            return None
+        # Recursive BVH construction
+        def build_bvh(objects, depth=0):
+            if len(objects) == 1:
+                return BVH.BVHNode(objects[0].aabb, objects=objects)
+            
+            # Split objects along the median axis based on their centroids
+            axis = depth % 3
+            objects.sort(key=lambda obj: obj.centroid[axis])
+            
+            mid = len(objects) // 2
+            left_bvh = build_bvh(objects[:mid], depth + 1)
+            right_bvh = build_bvh(objects[mid:], depth + 1)
+
+            # Merge left and right bounding boxes
+            combined_aabb = BVH.AABB(
+                np.minimum(left_bvh.aabb.min_point, right_bvh.aabb.min_point),
+                np.maximum(left_bvh.aabb.max_point, right_bvh.aabb.max_point)
+            )
+            
+            return BVH.BVHNode(combined_aabb, left_bvh, right_bvh)
+        
+        mesh_objects = []
+        for topology in topologyList:
+            vertices = [(Vertex.X(v), Vertex.Y(v), Vertex.Z(v)) for v in Topology.Vertices(topology)]
+            mesh_objects.append(BVH.MeshObject(vertices, topology))
+        
+        return build_bvh(mesh_objects)
+    
+    @staticmethod
+    def QueryByTopologies(*topologies, silent: bool = False):
+        """
+        Creates a BVH Query from the input list of topologies. The input can be individual topologies each as an input argument or a list of topologies stored in one input argument.
+
+        Parameters
+        ----------
+        topologies : list
+            The list of topologies.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        BVH query
+            The created BVH query.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+
+        if len(topologies) == 0:
+            print("BVH.QueryByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+            return None
+        if len(topologies) == 1:
+            topologyList = topologies[0]
+            if isinstance(topologyList, list):
+                if len(topologyList) == 0:
+                    if not silent:
+                        print("BVH.QueryByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
+                    return None
+                else:
+                    topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+                    if len(topologyList) == 0:
+                        if not silent:
+                            print("BVH.QueryByTopologies - Error: The input topologies parameter does not contain any valid topologies. Returning None.")
+                        return None
+            else:
+                if not silent:
+                    print("BVH.QueryByTopologies - Warning: The input topologies parameter contains only one topology. Returning the same topology.")
+                return topologies
+        else:
+            topologyList = Helper.Flatten(list(topologies))
+            topologyList = [x for x in topologyList if Topology.IsInstance(x, "Topology")]
+        if len(topologyList) == 0:
+            if not silent:
+                print("BVH.ByTopologies - Error: The input parameters do not contain any valid topologies. Returning None.")
+            return None
+        vertices = []
+        for topology in topologyList:
+            if Topology.IsInstance(topology, "Vertex"):
+                vertices.append(topology)
+            else:
+                vertices.extend(Topology.Vertices(topology))
+        cluster = Cluster.ByTopologies(vertices)
+        bb = Topology.BoundingBox(cluster)
+        d = Topology.Dictionary(bb)
+        min_x = Dictionary.ValueAtKey(d, "minx")
+        min_y = Dictionary.ValueAtKey(d, "miny")
+        min_z = Dictionary.ValueAtKey(d, "minz")
+        max_x = Dictionary.ValueAtKey(d, "maxx")
+        max_y = Dictionary.ValueAtKey(d, "maxy")
+        max_z = Dictionary.ValueAtKey(d, "maxz")
+        query_aabb = BVH.AABB(min_point=(min_x, min_y, min_z), max_point=(max_x,max_y,max_z))
+        return query_aabb
+    
+    def Clashes(bvh, query):
+        """
+        Returns a list of topologies in the input bvh tree that clashes (broad phase) with the list of topologies in the input query.
+
+        Parameters
+        ----------
+        topologies : list
+            The list of topologies.
+        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 clashing topologies (based on their axis-aligned bounding box (AABB))
+
+        """
+        # Function to perform clash detection (broad-phase) and return Topologic objects
+        def clash_detection(bvh_node, query_aabb, clashing_objects=None):
+            if clashing_objects is None:
+                clashing_objects = []
+            
+            # Check if the query AABB intersects with the current node's AABB
+            if not bvh_node.aabb.intersects(query_aabb):
+                return clashing_objects
+            
+            # If this is a leaf node, check each object in the node
+            if bvh_node.objects:
+                for obj in bvh_node.objects:
+                    if obj.aabb.intersects(query_aabb):
+                        clashing_objects.append(obj.topologic_object)  # Return the Topologic object
+                return clashing_objects
+            
+            # Recursively check the left and right child nodes
+            clash_detection(bvh_node.left, query_aabb, clashing_objects)
+            clash_detection(bvh_node.right, query_aabb, clashing_objects)
+            
+            return clashing_objects
+        return clash_detection(bvh, query)
+
+    # Function to recursively add nodes and edges to the TopologicPy Graph
+    def Graph(bvh, tolerance=0.0001):
+        """
+        Creates a graph from the input bvh tree.
+
+        Parameters
+        ----------
+        bvh : BVH Tree
+            The input BVH Tree.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.Graph
+            The created graph.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Graph import Graph
+        from topologicpy.Topology import Topology
+        import random
+        def add_bvh_to_graph(bvh_node, graph, parent_vertex=None, tolerance=0.0001):
+            # Create a vertex for the current node's AABB centroid
+            centroid = bvh_node.aabb.centroid
+            current_vertex = Vertex.ByCoordinates(x=centroid[0], y=centroid[1], z=centroid[2])
+
+            # Add an edge from the parent to this vertex (if a parent exists)
+            if parent_vertex is not None:
+                d = Vertex.Distance(parent_vertex, current_vertex)
+                if d < tolerance:
+                    current_vertex = Topology.Translate(current_vertex, tolerance*random.uniform(2,50), tolerance*random.uniform(2,50), tolerance*random.uniform(2,50))
+                edge = Edge.ByVertices(parent_vertex, current_vertex, tolerance=tolerance)
+                graph = Graph.AddEdge(graph, edge, silent=True)
+            
+            # Recursively add child nodes
+            if bvh_node.left:
+                graph = add_bvh_to_graph(bvh_node.left, graph, parent_vertex=current_vertex, tolerance=tolerance)
+            if bvh_node.right:
+                graph = add_bvh_to_graph(bvh_node.right, graph, parent_vertex=current_vertex, tolerance=tolerance)
+
+            return graph
+        graph = Graph.ByVerticesEdges([Vertex.Origin()], [])
+        return add_bvh_to_graph(bvh, graph, parent_vertex = None, tolerance=tolerance)

topologicpy/Edge.py

@@ -290,6 +290,7 @@ class Edge():
         """
         from topologicpy.Helper import Helper
         from topologicpy.Topology import Topology
+        import inspect
 
         if len(args) == 0:
             print("Edge.ByVertices - Error: The input vertices parameter is an empty list. Returning None.")
@@ -322,6 +323,9 @@ class Edge():
         if not edge:
             if not silent:
                 print("Edge.ByVertices - Error: Could not create an edge. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
         return edge
     
     @staticmethod
@@ -1135,17 +1139,22 @@ class Edge():
         from topologicpy.Topology import Topology
 
         def calculate_normal(start_vertex, end_vertex):
-            start_vertex = [float(x) for x in start_vertex]
-            end_vertex = [float(x) for x in end_vertex]
-            # Calculate the direction vector of the line segment
-            direction_vector = np.array(end_vertex) - np.array(start_vertex)
-
-            # Calculate the normal vector by swapping components and negating one of them
-            normal_vector = np.array([-direction_vector[1], direction_vector[0], 0])
-
-            # Normalize the normal vector
-            normal_vector /= norm(normal_vector)
+            start_vertex = np.array([float(x) for x in start_vertex])
+            end_vertex = np.array([float(x) for x in end_vertex])
 
+            # Calculate the direction vector of the edge
+            direction_vector = end_vertex - start_vertex
+            
+            # Handle the horizontal edge case (no Z component)
+            if np.isclose(direction_vector[2], 0):
+                # The edge lies in the X-Y plane; compute a perpendicular in the X-Y plane
+                normal_vector = np.array([-direction_vector[1], direction_vector[0], 0.0])
+            else:
+                # Otherwise, calculate the normal by crossing with the Z-axis
+                z_axis = np.array([0, 0, 1])
+                normal_vector = np.cross(direction_vector, z_axis)
+            
+            normal_vector /= norm(normal_vector)  # Normalize the normal vector
             return normal_vector
 
         def calculate_normal_line(start_vertex, end_vertex):
@@ -1156,7 +1165,7 @@ class Edge():
             normal_end_vertex = np.array(start_vertex) + normal_vector
 
             # Return the start and end vertices of the normal line
-            return start_vertex, list(normal_end_vertex)
+            return start_vertex, normal_end_vertex
 
         if not Topology.IsInstance(edge, "Edge"):
             print("Edge.NormalEdge - Error: The input edge parameter is not a valid edge. Returning None.")
@@ -1164,18 +1173,33 @@ class Edge():
         if length <= 0.0:
             print("Edge.NormalEdge - Error: The input length parameter is not a positive number greater than zero. Returning None.")
             return None
-        edge_direction = Edge.Direction(edge)
-        x, y, z = edge_direction
+
+        # Get start and end vertex coordinates
         start_vertex = Vertex.Coordinates(Edge.StartVertex(edge))
         end_vertex = Vertex.Coordinates(Edge.EndVertex(edge))
+
+        # Calculate the normal line
         normal_line_start, normal_line_end = calculate_normal_line(start_vertex, end_vertex)
-        sv = Vertex.ByCoordinates(normal_line_start)
+
+        # Create the normal edge in Topologic
+        sv = Vertex.ByCoordinates(list(normal_line_start))
         ev = Vertex.ByCoordinates(list(normal_line_end))
+        
+        # Create an edge from the start to the end of the normal vector
         normal_edge = Edge.ByVertices([sv, ev])
+
+        # Set the length of the normal edge
         normal_edge = Edge.SetLength(normal_edge, length, bothSides=False)
-        normal_edge = Topology.Rotate(normal_edge, origin=Edge.StartVertex(normal_edge), axis=[x,y,z], angle=angle)
-        dist = Edge.Length(edge)*u
+
+        # Rotate the normal edge around the input edge by the specified angle
+        edge_direction = Edge.Direction(edge)
+        x, y, z = edge_direction
+        normal_edge = Topology.Rotate(normal_edge, origin=Edge.StartVertex(normal_edge), axis=[x, y, z], angle=angle)
+
+        # Translate the normal edge along the edge direction according to the u parameter
+        dist = Edge.Length(edge) * u
         normal_edge = Topology.TranslateByDirectionDistance(normal_edge, edge_direction, dist)
+
         return normal_edge
 
     @staticmethod