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

topologicpy/Vector.py

@@ -275,13 +275,13 @@ class Vector(list):
         return [x, y, z]
     
     @staticmethod
-    def ByVertices(vertices, normalize: bool = True, mantissa: int = 6):
+    def ByVertices(*vertices, normalize: bool = True, mantissa: int = 6, silent: bool = False):
         """
         Creates a vector by the specified input list of vertices.
 
         Parameters
         ----------
-        vertices : list
+        *vertices : list
             The the input list of topologic vertices. The first element in the list is considered the start vertex. The last element in the list is considered the end vertex.
         normalize : bool , optional
             If set to True, the resulting vector is normalized (i.e. its length is set to 1)
@@ -296,16 +296,59 @@ class Vector(list):
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+        import inspect
 
-        if not isinstance(vertices, list):
+        if len(vertices) == 0:
+            if not silent:
+                print("Vector.ByVertices - Error: The input vertices parameter is an empty list. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
-        if not isinstance(normalize, bool):
+        if len(vertices) == 1:
+            vertices = vertices[0]
+            if isinstance(vertices, list):
+                if len(vertices) == 0:
+                    if not silent:
+                        print("Vector.ByVertices - Error: The input vertices parameter is an empty list. Returning None.")
+                        curframe = inspect.currentframe()
+                        calframe = inspect.getouterframes(curframe, 2)
+                        print('caller name:', calframe[1][3])
+                    return None
+                else:
+                    vertexList = [x for x in vertices if Topology.IsInstance(x, "Vertex")]
+                    if len(vertexList) == 0:
+                        if not silent:
+                            print("Vector.ByVertices - Error: The input vertices parameter does not contain any valid vertices. Returning None.")
+                            curframe = inspect.currentframe()
+                            calframe = inspect.getouterframes(curframe, 2)
+                            print('caller name:', calframe[1][3])
+                        return None
+            else:
+                if not silent:
+                    print("Vector.ByVertices - Warning: The input vertices parameter contains only one vertex. Returning None.")
+                    curframe = inspect.currentframe()
+                    calframe = inspect.getouterframes(curframe, 2)
+                    print('caller name:', calframe[1][3])
+                return None
+        else:
+            vertexList = Helper.Flatten(list(vertices))
+            vertexList = [x for x in vertexList if Topology.IsInstance(x, "Vertex")]
+        if len(vertexList) == 0:
+            if not silent:
+                print("Vector.ByVertices - Error: The input parameters do not contain any valid vertices. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
-        vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
-        if len(vertices) < 2:
+
+        if len(vertexList) < 2:
+            if not silent:
+                print("Vector.ByVertices - Error: The input parameters do not contain a minimum of two valid vertices. Returning None.")
             return None
-        v1 = vertices[0]
-        v2 = vertices[-1]
+        v1 = vertexList[0]
+        v2 = vertexList[-1]
         vector = [Vertex.X(v2, mantissa=mantissa)-Vertex.X(v1, mantissa=mantissa), Vertex.Y(v2, mantissa=mantissa)-Vertex.Y(v1, mantissa=mantissa), Vertex.Z(v2, mantissa=mantissa)-Vertex.Z(v1, mantissa=mantissa)]
         if normalize:
             vector = Vector.Normalize(vector)
@@ -345,11 +388,11 @@ class Vector(list):
             if not silent:
                 print("Vector.Coordinates - Error: The input vectorB parameter is not a valid vector. Returning Nonne.")
             return None
-        if abs(vectorA[0]) < tolerance and abs(vectorA[1]) < tolerance:
+        if abs(vectorA[0]) <= tolerance and abs(vectorA[1]) <= tolerance:
             if not silent:
                 print("Vector.CompassAngle - Error: The input vectorA parameter is vertical in the Z Axis. Returning Nonne.")
             return None
-        if abs(vectorB[0]) < tolerance and abs(vectorB[1]) < tolerance:
+        if abs(vectorB[0]) <= tolerance and abs(vectorB[1]) <= tolerance:
             if not silent:
                 print("Vector.CompassAngle - Error: The input vectorB parameter is vertical in the Z Axis. Returning Nonne.")
             return None
@@ -404,7 +447,7 @@ class Vector(list):
         x, y, z = vector
         
         # Handle the origin
-        if abs(x) < tolerance and abs(y) < tolerance and abs(z) < tolerance:
+        if abs(x) <= tolerance and abs(y) <= tolerance and abs(z) <= tolerance:
             return "Origin"
         
         # Normalize vector to prevent magnitude bias
@@ -412,9 +455,9 @@ class Vector(list):
         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
+        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:
@@ -553,18 +596,18 @@ class Vector(list):
             if not silent:
                 print("Vector.Cross - Error: The input vectorB parameter is not a valid vector. Returning None.")
             return None
-        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) < tolerance:
+        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) <= tolerance:
             if not silent:
                 print("Vector.Cross - Error: The magnitude of the input vectorA parameter is less than the input tolerance parameter. Returning None.")
             return None
-        if Vector.Magnitude(vector=vectorB, mantissa=mantissa) < tolerance:
+        if Vector.Magnitude(vector=vectorB, mantissa=mantissa) <= tolerance:
             if not silent:
                 print("Vector.Cross - Error: The magnitude of the input vectorB parameter is less than the input tolerance parameter. Returning None.")
             return None
         vecA = np.array(vectorA)
         vecB = np.array(vectorB)
         vecC = list(np.cross(vecA, vecB))
-        if Vector.Magnitude(vecC) < tolerance:
+        if Vector.Magnitude(vecC) <= tolerance:
             return [0, 0, 0]
         return [round(vecC[0], mantissa), round(vecC[1], mantissa), round(vecC[2], mantissa)]
 
@@ -600,11 +643,11 @@ class Vector(list):
             if not silent:
                 print("Vector.Dot - Error: The input vectorB parameter is not a valid vector. Returning None.")
             return None
-        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) < tolerance:
+        if Vector.Magnitude(vector=vectorA, mantissa=mantissa) <= tolerance:
             if not silent:
                 print("Vector.Dot - Error: The magnitude of the input vectorA parameter is less than the input tolerance parameter. Returning None.")
             return None
-        if Vector.Magnitude(vector=vectorB, mantissa=mantissa) < tolerance:
+        if Vector.Magnitude(vector=vectorB, mantissa=mantissa) <= tolerance:
             if not silent:
                 print("Vector.Dot - Error: The magnitude of the input vectorB parameter is less than the input tolerance parameter. Returning None.")
             return None
@@ -673,22 +716,26 @@ class Vector(list):
             return False
     
     @staticmethod
-    def IsCollinear(vectorA, vectorB):
+    def IsCollinear(vectorA, vectorB, tolerance=0.0001):
         """
-        Returns True if the input vectors are collinear (parallel or anti-parallel). Returns False otherwise.
-        
+        Returns True if the input vectors are collinear (parallel or anti-parallel) 
+        within a given tolerance. Returns False otherwise.
+
         Parameters
         ----------
         vectorA : list
             The first input vector.
         vectorB : list
             The second input vector.
+        tolerance : float, optional
+            The desired tolerance for determining collinearity. The default is 0.0001.
             
         Returns
         -------
         bool
-            True if the input vectors are collinear (parallel or anti-parallel). False otherwise.
-        
+            True if the input vectors are collinear (parallel or anti-parallel). 
+            False otherwise.
+
         """
         import numpy as np
 
@@ -700,17 +747,19 @@ class Vector(list):
         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
+        # Check if the dot product is within the tolerance of 1.0 or -1.0
         dot_product = np.dot(vector1_norm, vector2_norm)
-        if np.isclose(dot_product, 1.0) or np.isclose(dot_product, -1.0):
+        if (1.0 - tolerance) <= dot_product <= (1.0 + tolerance) or \
+        (-1.0 - tolerance) <= dot_product <= (-1.0 + tolerance):
             return True
         else:
             return False
     
     @staticmethod
-    def IsParallel(vectorA, vectorB):
+    def IsParallel(vectorA, vectorB, tolerance=0.0001):
         """
-        Returns True if the input vectors are parallel. Returns False otherwise.
+        Returns True if the input vectors are parallel within a given tolerance.
+        Returns False otherwise.
         
         Parameters
         ----------
@@ -718,12 +767,13 @@ class Vector(list):
             The first input vector.
         vectorB : list
             The second input vector.
+        tolerance : float, optional
+            The desired tolerance for determining parallelism. The default is 0.0001.
             
         Returns
         -------
         bool
             True if the input vectors are parallel. False otherwise.
-        
         """
         import numpy as np
 
@@ -735,14 +785,13 @@ class Vector(list):
         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
+        # Check if the dot product is within the tolerance of 1.0
         dot_product = np.dot(vector1_norm, vector2_norm)
-        if np.isclose(dot_product, 1.0):
+        if (1.0 - tolerance) <= dot_product <= (1.0 + tolerance):
             return True
         else:
-            # Compute bisecting vector
             return False
-    
+
     @staticmethod
     def IsSame(vectorA, vectorB, tolerance=0.0001):
         """
@@ -763,7 +812,7 @@ class Vector(list):
             True if the input vectors are the same. False otherwise.
         
         """
-        return all(abs(a - b) < tolerance for a, b in zip(vectorA, vectorB))
+        return all(abs(a - b) <= tolerance for a, b in zip(vectorA, vectorB))
 
     @staticmethod
     def Length(vector, mantissa: int = 6):
@@ -825,7 +874,7 @@ class Vector(list):
             The created vector that multiplies the input vector by the input magnitude.
 
         """
-        if abs(magnitude) < tolerance:
+        if abs(magnitude) <= tolerance:
             return [0.0] * len(vector)
         scaled_vector = [component * (magnitude) for component in vector]
         return scaled_vector

topologicpy/Vertex.py

@@ -801,7 +801,7 @@ class Vertex():
 
                     other_vertex = vertices[i]
                     distance = np.linalg.norm(np.array(vertex) - np.array(other_vertex))
-                    if distance < tolerance:
+                    if distance <= tolerance:
                         # Choose the coordinate with the least amount of decimal points
                         if count_decimal_points(other_vertex) < count_decimal_points(fused_vertex):
                             fused_vertex = other_vertex
@@ -870,7 +870,7 @@ class Vertex():
         incoming_edges = []
         for edge in edges:
             ev = Edge.EndVertex(edge)
-            if Vertex.Distance(vertex, ev) < tolerance:
+            if Vertex.Distance(vertex, ev) <= tolerance:
                 incoming_edges.append(edge)
         return incoming_edges
     
@@ -911,7 +911,7 @@ class Vertex():
                     return i
             else:
                 d = Vertex.Distance(vertex, vertices[i])
-                if d < tolerance:
+                if d <= tolerance:
                     return i
         return None
 
@@ -967,7 +967,7 @@ class Vertex():
 
             n_p = nearest_points[0]
             n_d = n_p[0]
-            if n_d < tolerance:
+            if n_d <= tolerance:
                 return n_p[1]
 
             # Calculate the weights for each nearest point based on inverse distance
@@ -1138,7 +1138,7 @@ class Vertex():
             return None
 
         if Topology.IsInstance(topology, "Vertex"):
-            return Vertex.Distance(vertex, topology) < tolerance
+            return Vertex.Distance(vertex, topology) <= tolerance
         elif Topology.IsInstance(topology, "Edge"):
             try:
                 parameter = Edge.ParameterAtVertex(topology, vertex)
@@ -1502,7 +1502,7 @@ class Vertex():
         outgoing_edges = []
         for edge in edges:
             sv = Edge.StartVertex(edge)
-            if Vertex.Distance(vertex, sv) < tolerance:
+            if Vertex.Distance(vertex, sv) <= tolerance:
                 outgoing_edges.append(edge)
         return outgoing_edges
     
@@ -1806,6 +1806,63 @@ class Vertex():
                 separated_vertices[i] = Topology.SetDictionary(separated_vertices[i], d)
         return separated_vertices
 
+    @staticmethod
+    def Transform(vertex, matrix, mantissa: int = 6, silent: bool = False):
+        """
+        Transforms a 3D vertex using a 4x4 transformation matrix.
+
+        Parameters
+        ----------
+        vertex : topologic_core.Vertex
+            The input vertex
+        matrix : list
+            The 4x4 transformation matrix.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Vertex
+            The transformed vertex.
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(vertex, "vertex"):
+            if not silent:
+                print("Vertex.Transform - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if not isinstance(matrix, list):
+            if not silent:
+                print("Vertex.Transform - Error: The input matrix parameter is not a valid 4X4 matrix. Returning None.")
+            return None
+        
+        matrix = np.array(matrix)  # Convert list to numpy array if necessary
+    
+        # Check if the shape of the matrix is (4, 4)
+        if not matrix.shape == (4, 4):
+            if not silent:
+                print("Vertex.Transform - Error: The input matrix parameter is not a valid 4X4 matrix. Returning None.")
+            return None
+        
+        # Convert the vertex to a 4D homogeneous coordinate
+        coords = Vertex.Coordinates(vertex, mantissa=mantissa)
+        homogeneous_coords= np.array([coords[0], coords[1], coords[2], 1.0])
+        
+        # Perform matrix multiplication
+        transformed_coords = np.dot(matrix, homogeneous_coords)
+        
+        # Convert back to 3D by dividing by w
+        if not np.isclose(transformed_coords[3], 0):  # Avoid division by zero
+            transformed_coords /= transformed_coords[3]
+        
+        # Return the transformed (x', y', z') as a list
+        coords = transformed_coords[:3].tolist()
+        coords = [round(v, mantissa) for v in coords]
+        return Vertex.ByCoordinates(coords)
+    
     @staticmethod
     def X(vertex, mantissa: int = 6) -> float:
         """