topologicpy 0.4.94__py3-none-any.whl → 0.4.96__py3-none-any.whl

topologicpy/Vector.py

@@ -147,6 +147,48 @@ class Vector(list):
             altitude = round(altitude, mantissa)
             return {"azimuth":azimuth, "altitude":altitude}
     
+    @staticmethod
+    def Bisect(vectorA, vectorB):
+        """
+        Compute the bisecting vector of two input vectors.
+        
+        Parameters
+        ----------
+        vectorA : list
+            The first input vector.
+        vectorB : list
+            The second input vector.
+            
+        Returns
+        -------
+        dict
+            The bisecting vector.
+        
+        """
+        import numpy as np
+
+
+        # Ensure vectors are numpy arrays
+        vector1 = np.array(vectorA)
+        vector2 = np.array(vectorB)
+        
+        # Normalize input vectors
+        vector1_norm = vector1 / np.linalg.norm(vector1)
+        vector2_norm = vector2 / np.linalg.norm(vector2)
+        
+        # Check if the angle between vectors is either 0 or 180 degrees
+        dot_product = np.dot(vector1_norm, vector2_norm)
+        if np.isclose(dot_product, 1.0) or np.isclose(dot_product, -1.0):
+            print("Vector.Bisect - Warning: The two vectors are collinear and thus the bisecting vector is not well-defined.")
+            # Angle is either 0 or 180 degrees, return any perpendicular vector
+            bisecting_vector = np.array([vector1[1] - vector1[2], vector1[2] - vector1[0], vector1[0] - vector1[1]])
+            bisecting_vector /= np.linalg.norm(bisecting_vector)
+        else:
+            # Compute bisecting vector
+            bisecting_vector = (vector1_norm + vector2_norm) / np.linalg.norm(vector1_norm + vector2_norm)
+    
+        return bisecting_vector
+    
     @staticmethod
     def ByAzimuthAltitude(azimuth, altitude, north=0, reverse=False, tolerance=0.0001):
         """
@@ -375,27 +417,153 @@ class Vector(list):
         return [1,0,0]
     
     @staticmethod
-    def IsCollinear(vectorA, vectorB, angTolerance=0.1):
+    def IsAntiParallel(vectorA, vectorB):
+        """
+        Returns True if the input vectors are anti-parallel. Returns False otherwise.
+        
+        Parameters
+        ----------
+        vectorA : list
+            The first input vector.
+        vectorB : list
+            The second input vector.
+            
+        Returns
+        -------
+        bool
+            True if the input vectors are anti-parallel. False otherwise.
+        
         """
-        Returns True if the input vectors are collinear. Returns False otherwise.
+        import numpy as np
 
+
+        # Ensure vectors are numpy arrays
+        vector1 = np.array(vectorA)
+        vector2 = np.array(vectorB)
+        
+        # Normalize input vectors
+        vector1_norm = vector1 / np.linalg.norm(vector1)
+        vector2_norm = vector2 / np.linalg.norm(vector2)
+        
+        # Check if the angle between vectors is either 0 or 180 degrees
+        dot_product = np.dot(vector1_norm, vector2_norm)
+        if np.isclose(dot_product, -1.0):
+            return True
+        else:
+            # Compute bisecting vector
+            return False
+    
+    @staticmethod
+    def IsParallel(vectorA, vectorB):
+        """
+        Returns True if the input vectors are parallel. Returns False otherwise.
+        
         Parameters
         ----------
         vectorA : list
             The first input vector.
         vectorB : list
             The second input vector.
-        angTolerance : float, optional
-            The desired angular tolerance. The default is 0.1
+            
+        Returns
+        -------
+        bool
+            True if the input vectors are parallel. False otherwise.
+        
+        """
+        import numpy as np
 
+
+        # Ensure vectors are numpy arrays
+        vector1 = np.array(vectorA)
+        vector2 = np.array(vectorB)
+        
+        # Normalize input vectors
+        vector1_norm = vector1 / np.linalg.norm(vector1)
+        vector2_norm = vector2 / np.linalg.norm(vector2)
+        
+        # Check if the angle between vectors is either 0 or 180 degrees
+        dot_product = np.dot(vector1_norm, vector2_norm)
+        if np.isclose(dot_product, 1.0):
+            return True
+        else:
+            # Compute bisecting vector
+            return False
+    
+    @staticmethod
+    def IsCollinear(vectorA, vectorB):
+        """
+        Returns True if the input vectors are collinear (parallel or anti-parallel). Returns False otherwise.
+        
+        Parameters
+        ----------
+        vectorA : list
+            The first input vector.
+        vectorB : list
+            The second input vector.
+            
         Returns
         -------
         bool
-            Returns True if the input vectors are collinear. Returns False otherwise.
+            True if the input vectors are collinear (parallel or anti-parallel). False otherwise.
+        
         """
+        import numpy as np
 
-        return Vector.Angle(vectorA, vectorB) < angTolerance
 
+        # Ensure vectors are numpy arrays
+        vector1 = np.array(vectorA)
+        vector2 = np.array(vectorB)
+        
+        # Normalize input vectors
+        vector1_norm = vector1 / np.linalg.norm(vector1)
+        vector2_norm = vector2 / np.linalg.norm(vector2)
+        
+        # Check if the angle between vectors is either 0 or 180 degrees
+        dot_product = np.dot(vector1_norm, vector2_norm)
+        if np.isclose(dot_product, 1.0) or np.isclose(dot_product, -1.0):
+            return True
+        else:
+            # Compute bisecting vector
+            return False
+    
+    @staticmethod
+    def IsParallel(vectorA, vectorB):
+        """
+        Returns True if the input vectors are parallel. Returns False otherwise.
+        
+        Parameters
+        ----------
+        vectorA : list
+            The first input vector.
+        vectorB : list
+            The second input vector.
+            
+        Returns
+        -------
+        bool
+            True if the input vectors are parallel. False otherwise.
+        
+        """
+        import numpy as np
+
+
+        # Ensure vectors are numpy arrays
+        vector1 = np.array(vectorA)
+        vector2 = np.array(vectorB)
+        
+        # Normalize input vectors
+        vector1_norm = vector1 / np.linalg.norm(vector1)
+        vector2_norm = vector2 / np.linalg.norm(vector2)
+        
+        # Check if the angle between vectors is either 0 or 180 degrees
+        dot_product = np.dot(vector1_norm, vector2_norm)
+        if np.isclose(dot_product, 1.0):
+            return True
+        else:
+            # Compute bisecting vector
+            return False
+    
     @staticmethod
     def Magnitude(vector, mantissa: int = 6):
         """
@@ -606,6 +774,75 @@ class Vector(list):
     
         return sum_dimensions
     
+    @staticmethod
+    def TransformationMatrix(vectorA, vectorB):
+        """
+        Returns the transformation matrix needed to align vectorA with vectorB.
+
+        Parameters
+        ----------
+        vectorA : list
+            The input vector to be transformed.
+        vectorB : list
+            The desired vector with which to align vectorA.
+        
+        Returns
+        -------
+        list
+            Transformation matrix that follows the Blender software convention (nested list)
+        """
+        import numpy as np
+        from topologicpy.Matrix import Matrix
+
+        import numpy as np
+
+        def transformation_matrix(vec1, vec2, translation_vector=None):
+            """
+            Compute a 4x4 transformation matrix that aligns vec1 to vec2.
+            
+            :param vec1: A 3D "source" vector
+            :param vec2: A 3D "destination" vector
+            :param translation_vector: Optional translation vector (default is None)
+            :return: The 4x4 transformation matrix
+            """
+            vec1 = vec1 / np.linalg.norm(vec1)
+            vec2 = vec2 / np.linalg.norm(vec2)
+            dot_product = np.dot(vec1, vec2)
+            
+            if np.isclose(dot_product, 1.0):
+                # Vectors are parallel; return the identity matrix
+                return np.eye(4)
+            elif np.isclose(dot_product, -1.0):
+                # Vectors are antiparallel; reflect one of the vectors about the origin
+                reflection_matrix = np.eye(4)
+                reflection_matrix[2, 2] = -1
+                return reflection_matrix
+            
+            cross_product = np.cross(vec1, vec2)
+            
+            skew_symmetric_matrix = np.array([[0, -cross_product[2], cross_product[1], 0],
+                                            [cross_product[2], 0, -cross_product[0], 0],
+                                            [-cross_product[1], cross_product[0], 0, 0],
+                                            [0, 0, 0, 1]])
+            
+            rotation_matrix = np.eye(4) + skew_symmetric_matrix + \
+                            np.dot(skew_symmetric_matrix, skew_symmetric_matrix) * \
+                            (1 / (1 + dot_product))
+            
+            if translation_vector is not None:
+                translation_matrix = np.eye(4)
+                translation_matrix[:3, 3] = translation_vector
+                transformation_matrix = np.dot(translation_matrix, rotation_matrix)
+            else:
+                transformation_matrix = rotation_matrix
+            
+            return transformation_matrix
+
+
+        tran_mat = transformation_matrix(vectorA, vectorB)
+        
+        return [list(tran_mat[0]), list(tran_mat[1]), list(tran_mat[2]), list(tran_mat[3])]
+    
     @staticmethod
     def Up():
         """

topologicpy/Vertex.py

@@ -78,7 +78,7 @@ class Vertex(Topology):
             return None
         if len(vertexList) < 3:
             return True # Any two vertices can form a line!
-        cluster = Topology.SelfMerge(Cluster.ByTopologies(vertexList))
+        cluster = Topology.SelfMerge(Cluster.ByTopologies(vertexList), tolerance=tolerance)
         vertexList = Topology.Vertices(cluster)
         slices = []
         for i in range(2,len(vertexList)):
@@ -537,7 +537,7 @@ class Vertex(Topology):
         
         def distance_to_face(vertex, face, includeCentroid):
             v_proj = Vertex.Project(vertex, face, mantissa=mantissa)
-            if not Face.IsInternal(face, v_proj):
+            if not Vertex.IsInternal(v_proj, face):
                 vertices = Topology.Vertices(topology)
                 distances = [distance_to_vertex(vertex, v) for v in vertices]
                 edges = Topology.Edges(topology)
@@ -867,15 +867,70 @@ class Vertex(Topology):
         return vertex
 
     @staticmethod
-    def IsInside(vertex: topologic.Vertex, topology: topologic.Topology, tolerance: float = 0.0001) -> bool:
+    def IsCoincident(vertexA: topologic.Vertex, vertexB: topologic.Vertex, tolerance: float = 0.0001, silent: bool = False) -> bool:
         """
-        DEPRECATED. DO NOT USE. INSTEAD USE Vertex.IsInternal.
+        Returns True if the input vertexA is coincident with the input vertexB. Returns False otherwise.
+
+        Parameters
+        ----------
+        vertexA : topologic.Vertex
+            The first input vertex.
+        vertexB : topologic.Vertex
+            The second input vertex.
+        tolerance : float , optional
+            The tolerance for computing if the input vertexA is coincident with the input vertexB. The default is 0.0001.
+
+        Returns
+        -------
+        bool
+            True if the input vertexA is coincident with the input vertexB. False otherwise.
+
         """
-        print("Vertex.IsInside - Warning: Deprecated method. This method will be removed in the future. Instead, use Vertex.IsInternal.")
-        return Vertex.IsInternal(vertex=vertex, topology=topology, tolerance=tolerance)
+        if not isinstance(vertexA, topologic.Vertex):
+            if not silent:
+                print("Vertex.IsCoincident - Error: The input vertexA parameter is not a valid vertex. Returning None.")
+            return None
+        if not isinstance(vertexB, topologic.Vertex):
+            if not silent:
+                print("Vertex.IsICoincident - Error: The input vertexB parameter is not a valid vertex. Returning None.")
+            return None
+        return Vertex.IsInternal(vertexA, vertexB, tolerance=tolerance, silent=silent)
 
     @staticmethod
-    def IsInternal(vertex: topologic.Vertex, topology: topologic.Topology, tolerance: float = 0.0001) -> bool:
+    def IsExternal(vertex: topologic.Vertex, topology: topologic.Topology, tolerance: float = 0.0001, silent: bool = False) -> bool:
+        """
+        Returns True if the input vertex is external to the input topology. Returns False otherwise.
+
+        Parameters
+        ----------
+        vertex : topologic.Vertex
+            The input vertex.
+        topology : topologic.Topology
+            The input topology.
+        tolerance : float , optional
+            The tolerance for computing if the input vertex is external to the input topology. The default is 0.0001.
+        silent : bool , optional
+            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+
+        Returns
+        -------
+        bool
+            True if the input vertex is external to the input topology. False otherwise.
+
+        """
+
+        if not isinstance(vertex, topologic.Vertex):
+            if not silent:
+                print("Vertex.IsExternal - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        if not isinstance(topology, topologic.Topology):
+            if not silent:
+                print("Vertex.IsExternal - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        return not (Vertex.IsPeripheral(vertex, topology, tolerance=tolerance, silent=silent) or Vertex.IsInternal(vertex, topology, tolerance=tolerance, silent=silent))
+    
+    @staticmethod
+    def IsInternal(vertex: topologic.Vertex, topology: topologic.Topology, tolerance: float = 0.0001, silent: bool = False) -> bool:
         """
         Returns True if the input vertex is inside the input topology. Returns False otherwise.
 
@@ -886,14 +941,17 @@ class Vertex(Topology):
         topology : topologic.Topology
             The input topology.
         tolerance : float , optional
-            The tolerance for computing if the input vertex is enclosed in a cell. The default is 0.0001.
+            The tolerance for computing if the input vertex is internal to the input topology. The default is 0.0001.
+        silent : bool , optional
+            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
 
         Returns
         -------
         bool
-            True if the input vertex is inside the input topology. False otherwise.
+            True if the input vertex is internal to the input topology. False otherwise.
 
         """
+        from topologicpy.Edge import Edge
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Shell import Shell
@@ -901,8 +959,12 @@ class Vertex(Topology):
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         if not isinstance(vertex, topologic.Vertex):
+            if not silent:
+                print("Vertex.IsInternal - Error: The input vertex parameter is not a valid vertex. Returning None.")
             return None
         if not isinstance(topology, topologic.Topology):
+            if not silent:
+                print("Vertex.IsInternal - Error: The input topology parameter is not a valid topology. Returning None.")
             return None
 
         if isinstance(topology, topologic.Vertex):
@@ -914,39 +976,163 @@ class Vertex(Topology):
                 parameter = 400 #aribtrary large number greater than 1
             return 0 <= parameter <= 1
         elif isinstance(topology, topologic.Wire):
+            vertices = [v for v in Topology.Vertices(topology) if Vertex.Degree(v, topology) > 1]
             edges = Wire.Edges(topology)
-            for edge in edges:
-                if Vertex.IsInternal(vertex, edge, tolerance):
+            sub_list = vertices + edges
+            for sub in sub_list:
+                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
                     return True
             return False
         elif isinstance(topology, topologic.Face):
-            return Face.IsInternal(topology, vertex, tolerance)
+            # Test the distance first
+            if Vertex.PerpendicularDistance(vertex, topology) > tolerance:
+                return False
+            if Vertex.IsPeripheral(vertex, topology):
+                return False
+            normal = Face.Normal(topology)
+            proj_v = Vertex.Project(vertex, topology)
+            v1 = Topology.TranslateByDirectionDistance(proj_v, normal, 1)
+            v2 = Topology.TranslateByDirectionDistance(proj_v, normal, -1)
+            edge = Edge.ByVertices(v1, v2)
+            intersect = edge.Intersect(topology)
+            if intersect == None:
+                return False
+            return True
         elif isinstance(topology, topologic.Shell):
-            faces = Shell.Faces(topology)
-            for face in faces:
-                if Vertex.IsInternal(vertex, face, tolerance):
+            if Vertex.IsPeripheral(vertex, topology, tolerance=tolerance, silent=silent):
+                return False
+            else:
+                edges = Topology.Edges(topology)
+                for edge in edges:
+                    if Vertex.IsInternal(vertex, edge, tolerance=tolerance, silent=silent):
+                        return True
+                faces = Topology.Faces(topology)
+                for face in faces:
+                    if Vertex.IsInternal(vertex, face, tolerance=tolerance, silent=silent):
+                        return True
+                return False
+        elif isinstance(topology, topologic.Cell):
+            return topologic.CellUtility.Contains(topology, vertex, tolerance) == 0
+        elif isinstance(topology, topologic.CellComplex):
+            ext_boundary = CellComplex.ExternalBoundary(topology)
+            return Vertex.IsInternal(vertex, ext_boundary, tolerance=tolerance, silent=silent)
+        elif isinstance(topology, topologic.Cluster):
+            sub_list = Cluster.FreeTopologies(topology)
+            for sub in sub_list:
+                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
+                    return True
+            return False
+        return False
+    
+    
+    @staticmethod
+    def IsPeripheral(vertex: topologic.Vertex, topology: topologic.Topology, tolerance: float = 0.0001, silent: bool = False) -> bool:
+        """
+        Returns True if the input vertex is peripheral to the input topology. Returns False otherwise.
+        A vertex is said to be peripheral to the input topology if:
+            01. Vertex: If it is internal to it (i.e. coincident with it).
+            02. Edge: If it is internal to its start or end vertices.
+            03. Manifold open wire: If it is internal to its start or end vertices.
+            04. Manifold closed wire: If it is internal to any of its vertices.
+            05. Non-manifold wire: If it is internal to any of its vertices that has a vertex degree of 1.
+            06. Face: If it is internal to any of its edges or vertices.
+            07. Shell: If it is internal to external boundary
+            08. Cell: If it is internal to any of its faces, edges, or vertices.
+            09. CellComplex: If it is peripheral to its external boundary.
+            10. Cluster: If it is peripheral to any of its free topologies. (See Cluster.FreeTopologies)
+
+        Parameters
+        ----------
+        vertex : topologic.Vertex
+            The input vertex.
+        topology : topologic.Topology
+            The input topology.
+        tolerance : float , optional
+            The tolerance for computing if the input vertex is peripheral to the input topology. The default is 0.0001.
+        silent : bool , optional
+            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
+
+        Returns
+        -------
+        bool
+            True if the input vertex is peripheral to the input topology. False otherwise.
+
+        """
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Shell import Shell
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        
+        if not isinstance(vertex, topologic.Vertex):
+            if not silent:
+                print("Vertex.IsPeripheral - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        if not isinstance(topology, topologic.Topology):
+            if not silent:
+                print("Vertex.IsPeripheral - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+
+        if isinstance(topology, topologic.Vertex):
+            return Vertex.IsInternal(vertex, topology, tolerance=tolerance, silent=silent)
+        elif isinstance(topology, topologic.Edge):
+            sv = Edge.StartVertex(topology)
+            ev = Edge.EndVertex(topology)
+            f1 = Vertex.IsInternal(vertex, sv, tolerance=tolerance, silent=silent)
+            f2 = Vertex.IsInternal(vertex, ev, tolerance=tolerance, silent=silent)
+            return f1 or f2
+        elif isinstance(topology, topologic.Wire):
+            if Wire.IsManifold(topology):
+                if not Wire.IsClosed(topology):
+                    sv = Wire.StartVertex(topology)
+                    ev = Wire.EndVertex(topology)
+                    f1 = Vertex.IsInternal(vertex, sv, tolerance=tolerance, silent=silent)
+                    f2 = Vertex.IsInternal(vertex, ev, tolerance=tolerance, silent=silent)
+                    return f1 or f2
+                else:
+                    sub_list = [v for v in Topology.Vertices(topology)]
+                    for sub in sub_list:
+                        if Vertex.IsPeripheral(vertex, sub, tolerance=tolerance, silent=silent):
+                            return True
+                    return False
+            else:
+                sub_list = [v for v in Topology.Vertices(topology) if Vertex.Degree(v, topology) == 1]
+                for sub in sub_list:
+                    if Vertex.IsPeripheral(vertex, sub, tolerance=tolerance, silent=silent):
+                        return True
+                return False
+        elif isinstance(topology, topologic.Face):
+            sub_list = Topology.Vertices(topology) + Topology.Edges(topology)
+            for sub in sub_list:
+                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
+                    return True
+            return False
+        elif isinstance(topology, topologic.Shell):
+            ext_boundary = Shell.ExternalBoundary(topology)
+            sub_list = Topology.Vertices(ext_boundary) + Topology.Edges(ext_boundary)
+            for sub in sub_list:
+                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
                     return True
             return False
         elif isinstance(topology, topologic.Cell):
-            return topologic.CellUtility.Contains(topology, vertex, tolerance) == 0
+            sub_list = Topology.Vertices(topology) + Topology.Edges(topology) + Topology.Faces(topology)
+            for sub in sub_list:
+                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
+                    return True
+            return False
         elif isinstance(topology, topologic.CellComplex):
-            cells = CellComplex.Cells(topology)
-            faces = CellComplex.Faces(topology)
-            edges = CellComplex.Edges(topology)
-            vertices = CellComplex.Vertices(topology)
-            subtopologies = cells + faces + edges + vertices
-            for subtopology in subtopologies:
-                if Vertex.IsInternal(vertex, subtopology, tolerance):
+            ext_boundary = CellComplex.ExternalBoundary(topology)
+            sub_list = Topology.Vertices(ext_boundary) + Topology.Edges(ext_boundary) + Topology.Faces(ext_boundary)
+            for sub in sub_list:
+                if Vertex.IsInternal(vertex, sub, tolerance=tolerance, silent=silent):
                     return True
             return False
         elif isinstance(topology, topologic.Cluster):
-            cells = Cluster.Cells(topology)
-            faces = Cluster.Faces(topology)
-            edges = Cluster.Edges(topology)
-            vertices = Cluster.Vertices(topology)
-            subtopologies = cells + faces + edges + vertices
-            for subtopology in subtopologies:
-                if Vertex.IsInternal(vertex, subtopology, tolerance):
+            sub_list = Cluster.FreeTopologies(topology)
+            for sub in sub_list:
+                if Vertex.IsPeripheral(vertex, sub, tolerance=tolerance, silent=silent):
                     return True
             return False
         return False