topologicpy 0.7.99__py3-none-any.whl → 0.8.2__py3-none-any.whl

topologicpy/Matrix.py

@@ -49,70 +49,47 @@ class Matrix:
 
     @staticmethod
     def ByRotation(angleX=0, angleY=0, angleZ=0, order="xyz"):
-        """
-        Creates a 4x4 rotation matrix.
-
-        Parameters
-        ----------
-        angleX : float , optional
-            The desired rotation angle in degrees around the X axis. The default is 0.
-        angleY : float , optional
-            The desired rotation angle in degrees around the Y axis. The default is 0.
-        angleZ : float , optional
-            The desired rotation angle in degrees around the Z axis. The default is 0.
-        order : string , optional
-            The order by which the roatations will be applied. The possible values are any permutation of "xyz". This input is case insensitive. The default is "xyz".
-
-        Returns
-        -------
-        list
-            The created 4X4 rotation matrix.
-
-        """
         def rotateXMatrix(radians):
-            """ Return matrix for rotating about the x-axis by 'radians' radians """
             c = math.cos(radians)
             s = math.sin(radians)
             return [[1, 0, 0, 0],
-                    [0, c,-s, 0],
+                    [0, c, -s, 0],
                     [0, s, c, 0],
                     [0, 0, 0, 1]]
 
         def rotateYMatrix(radians):
-            """ Return matrix for rotating about the y-axis by 'radians' radians """
-            
             c = math.cos(radians)
             s = math.sin(radians)
-            return [[ c, 0, s, 0],
-                    [ 0, 1, 0, 0],
+            return [[c, 0, s, 0],
+                    [0, 1, 0, 0],
                     [-s, 0, c, 0],
-                    [ 0, 0, 0, 1]]
+                    [0, 0, 0, 1]]
 
         def rotateZMatrix(radians):
-            """ Return matrix for rotating about the z-axis by 'radians' radians """
-            
             c = math.cos(radians)
             s = math.sin(radians)
-            return [[c,-s, 0, 0],
+            return [[c, -s, 0, 0],
                     [s, c, 0, 0],
                     [0, 0, 1, 0],
                     [0, 0, 0, 1]]
-        
+
         xMat = rotateXMatrix(math.radians(angleX))
         yMat = rotateYMatrix(math.radians(angleY))
         zMat = rotateZMatrix(math.radians(angleZ))
+
         if order.lower() == "xyz":
-            return Matrix.Multiply(Matrix.Multiply(zMat,yMat),xMat)
+            return Matrix.Multiply(Matrix.Multiply(zMat, yMat), xMat)
         if order.lower() == "xzy":
-            return Matrix.Multiply(Matrix.Multiply(yMat,zMat),xMat)
+            return Matrix.Multiply(Matrix.Multiply(yMat, zMat), xMat)
         if order.lower() == "yxz":
-            return Matrix.Multiply(Matrix.Multiply(zMat,xMat),yMat)
-        if order.lower == "yzx":
-            return Matrix.Multiply(Matrix.Multiply(xMat,zMat),yMat)
+            return Matrix.Multiply(Matrix.Multiply(zMat, xMat), yMat)
+        if order.lower() == "yzx":
+            return Matrix.Multiply(Matrix.Multiply(xMat, zMat), yMat)
         if order.lower() == "zxy":
-            return Matrix.Multiply(Matrix.Multiply(yMat,xMat),zMat)
+            return Matrix.Multiply(Matrix.Multiply(yMat, xMat), zMat)
         if order.lower() == "zyx":
-            return Matrix.Multiply(Matrix.Multiply(xMat,yMat),zMat)
+            return Matrix.Multiply(Matrix.Multiply(xMat, yMat), zMat)
+
     
     @staticmethod
     def ByScaling(scaleX=1.0, scaleY=1.0, scaleZ=1.0):
@@ -159,10 +136,10 @@ class Matrix:
             The created 4X4 translation matrix.
 
         """
-        return [[1,0,0,0],
-                [0,1,0,0],
-                [0,0,1,0],
-                [translateX,translateY,translateZ,1]]
+        return [[1,0,0,translateX],
+                [0,1,0,translateY],
+                [0,0,1,translateZ],
+                [0,0,0,1]]
     
     @staticmethod
     def EigenvaluesAndVectors(matrix, mantissa: int = 6, silent: bool = False):
@@ -230,47 +207,42 @@ class Matrix:
     @staticmethod
     def Multiply(matA, matB):
         """
-        Multiplies the two input matrices. When transforming an object, the first input matrix is applied first
-        then the second input matrix.
-        
+        Multiplies two matrices (matA and matB). The first matrix (matA) is applied first in the transformation,
+        followed by the second matrix (matB).
+
         Parameters
         ----------
-        matA : list
+        matA : list of list of float
             The first input matrix.
-        matB : list
+        matB : list of list of float
             The second input matrix.
 
         Returns
         -------
-        list
-            The matrix resulting from the multiplication of the two input matrices.
+        list of list of float
+            The resulting matrix after multiplication.
 
         """
-        if not isinstance(matA, list):
-            return None
-        if not isinstance(matB, list):
-            return None
-        nr = len(matA)
-        nc = len(matA[0])
-        matC = []
-        for i in range(nr):
-            tempRow = []
-            for j in range(nc):
-                tempRow.append(0)
-            matC.append(tempRow)
-        if not isinstance(matA, list):
-            return None
-        if not isinstance(matB, list):
-            return None
-        # iterate through rows of X
-        for i in range(len(matA)):
-            # iterate through columns of Y
-            tempRow = []
-            for j in range(len(matB[0])):
-                # iterate through rows of Y
-                for k in range(len(matB)):
-                    matC[i][j] += matA[i][k] * matB[k][j]
-        return matC
+        # Input validation
+        if not (isinstance(matA, list) and all(isinstance(row, list) for row in matA) and
+                isinstance(matB, list) and all(isinstance(row, list) for row in matB)):
+            raise ValueError("Both inputs must be 2D lists representing matrices.")
+        
+        # Check matrix dimension compatibility
+        if len(matA[0]) != len(matB):
+            raise ValueError("Number of columns in matA must equal the number of rows in matB.")
+
+        # Dimensions of the resulting matrix
+        rows_A, cols_A = len(matA), len(matA[0])
+        rows_B, cols_B = len(matB), len(matB[0])
+        result = [[0.0] * cols_B for _ in range(rows_A)]
+
+        # Matrix multiplication
+        for i in range(rows_A):
+            for j in range(cols_B):
+                result[i][j] = sum(matA[i][k] * matB[k][j] for k in range(cols_A))
+
+        return result
 
     @staticmethod
     def Subtract(matA, matB):

topologicpy/Topology.py

@@ -6492,6 +6492,87 @@ class Topology():
             return None
         return topologic.Topology.IsSame(topologyA, topologyB)
     
+    def IsVertexMatched(topologyA, topologyB, mantissa: int = 6, tolerance=0.0001, silent : bool = False):
+        """
+        Returns True if the input topologies are vertex matched (have same number of vertices and all vertices are coincedent within a tolerance). Returns False otherwise.
+
+        Parameters
+        ----------
+        topologyA : topologic_core.Topology
+            The first input topology.
+        topologyB : topologic_core.Topology
+            The second input topology.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6
+        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
+        -------
+        bool
+            True of the input topologies are vertex matched. False otherwise.
+
+        """
+        from topologicpy.Vertex import Vertex
+
+        def coordinates_match(list1, list2, tolerance):
+            """
+            Checks if all coordinates in list1 have a corresponding coordinate in list2
+            within a specified tolerance, with each match being unique.
+
+            Parameters
+            ----------
+            list1 : list of list of float
+                The first list of coordinates, where each coordinate is [x, y, z].
+            list2 : list of list of float
+                The second list of coordinates, where each coordinate is [x, y, z].
+            tolerance : float
+                The maximum distance within which two coordinates are considered matching.
+
+            Returns
+            -------
+            bool
+                True if all coordinates in list1 have a corresponding coordinate in list2
+                within the tolerance. False otherwise.
+            """
+            def distance(coord1, coord2):
+                """Calculate the Euclidean distance between two coordinates."""
+                return np.linalg.norm(np.array(coord1) - np.array(coord2))
+
+            # Copy list2 to keep track of unvisited coordinates
+            unmatched = list2.copy()
+
+            for coord1 in list1:
+                match_found = False
+                for i, coord2 in enumerate(unmatched):
+                    if distance(coord1, coord2) <= tolerance:
+                        # Mark the coordinate as visited by removing it
+                        unmatched.pop(i)
+                        match_found = True
+                        break
+                if not match_found:
+                    return False
+            return True
+
+        if not Topology.IsInstance(topologyA, "topology"):
+            if not silent:
+                print("Topology.IsVertexMatched - Error: The input topologyA parameter is not a valid topology. Returning None.")
+            return None
+        if not Topology.IsInstance(topologyB, "topology"):
+            if not silent:
+                print("Topology.IsVertexMatched - Error: The input topologyB parameter is not a valid topology. Returning None.")
+            return None
+        
+        vertices_a = Topology.Vertices(topologyA)
+        vertices_b = Topology.Vertices(topologyB)
+        if not len(vertices_a) == len(vertices_b):
+            return False
+        coords_a = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices_a]
+        coords_b = [Vertex.Coordinates(v, mantissa=mantissa) for v in vertices_b]
+        return coordinates_match(coords_a, coords_b, tolerance=tolerance)
+
     @staticmethod
     def MergeAll(topologies, tolerance=0.0001):
         """
@@ -9229,9 +9310,9 @@ class Topology():
         kRotation31 = matrix[2][0]
         kRotation32 = matrix[2][1]
         kRotation33 = matrix[2][2]
-        kTranslationX = matrix[3][0]
-        kTranslationY = matrix[3][1]
-        kTranslationZ = matrix[3][2]
+        kTranslationX = matrix[0][3]
+        kTranslationY = matrix[1][3]
+        kTranslationZ = matrix[2][3]
 
         return_topology = topologic.TopologyUtility.Transform(topology, kTranslationX, kTranslationY, kTranslationZ, kRotation11, kRotation12, kRotation13, kRotation21, kRotation22, kRotation23, kRotation31, kRotation32, kRotation33)