topologicpy 0.8.14__py3-none-any.whl → 0.8.15__py3-none-any.whl

topologicpy/Cell.py

@@ -1909,7 +1909,7 @@ class Cell():
             uRect = Wire.Rectangle(origin=origin, width=height*1.2, length=length*1.2, direction=[1, 0, 0], placement="center")
             for i in range(1, uSides):
                 sliceFaces.append(Topology.Translate(Face.ByWire(uRect, tolerance=tolerance), width/uSides*i - width*0.5, 0, 0))
-            vRect = Wire.Rectangle(origin=origin, width=height*1.2, length=width*1.2, direction=[0, 1, 0], placement="center")
+            vRect = Wire.Rectangle(origin=origin, length=height*1.2, width=width*1.2, direction=[0, 1, 0], placement="center")
             for i in range(1, vSides):
                 sliceFaces.append(Topology.Translate(Face.ByWire(vRect, tolerance=tolerance), 0, length/vSides*i - length*0.5, 0))
             if len(sliceFaces) > 0:

topologicpy/Matrix.py

@@ -47,6 +47,83 @@ class Matrix:
             matC.append(tempRow)
         return matC
 
+    @staticmethod
+    def ByCoordinateSystems(source, target, mantissa: int = 6, silent: bool = False):
+        """
+        Calculates the 4x4 transformation matrix that maps the source coordinate system to the target coordinate system.
+        An example of a coordinate system matrix is:
+        source = [
+        [0, 0, 0],  # Origin
+        [1, 0, 0],  # X-axis
+        [0, 1, 0],  # Y-axis
+        [0, 0, 1]   # Z-axis
+        ]
+        
+        Parameters
+        ----------
+        source : list
+            The 4X3 matrix representing source coordinate system. The rows are in the order: Origin, X-Axis, Y-Axis, Z-Axis.
+        target : list
+            The 4X3 matrix representing target coordinate system. The rows are in the order: Origin, X-Axis, Y-Axis, Z-Axis.
+        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
+        -------
+        list
+            The 4x4 transformation matrix.
+        """
+        import numpy as np
+
+        if not isinstance(source, list):
+            if not silent:
+                print("Matrix.ByCoordinateSystems - Error: The source input parameter is not a valid list. Returning None.")
+            return None
+        if not isinstance(target, list):
+            if not silent:
+                print("Matrix.ByCoordinateSystems - Error: The taget input parameter is not a valid list. Returning None.")
+            return None
+        
+        # Convert to numpy arrays
+        source_matrix = np.array(source)
+        target_matrix = np.array(target)
+
+        if source_matrix.shape != (4, 3):
+            if not silent:
+                print("Matrix.ByCoordinateSystems - Error: The source input parameter must be 4x3 matrix. Returning None.")
+            return None
+        if target_matrix.shape != (4, 3):
+            if not silent:
+                print("Matrix.ByCoordinateSystems - Error: The target input parameter must be 4x3 matrix. Returning None.")
+            return None
+        
+        # Convert input matrices to homogeneous transformations
+        source_to_world = np.eye(4)
+        source_to_world[:3, 0] = source_matrix[1, :] # X-axis
+        source_to_world[:3, 1] = source_matrix[2, :] # Y-axis
+        source_to_world[:3, 2] = source_matrix[3, :] # Z-axis
+        source_to_world[:3, 3] = source_matrix[0, :] # Origin
+
+        target_to_world = np.eye(4)
+        target_to_world[:3, 0] = target_matrix[1, :] # X-axis
+        target_to_world[:3, 1] = target_matrix[2, :] # Y-axis
+        target_to_world[:3, 2] = target_matrix[3, :] # Z-axis
+        target_to_world[:3, 3] = target_matrix[0, :] # Origin
+
+        # Compute the world-to-source transformation (inverse of source_to_world)
+        world_to_source = np.linalg.inv(source_to_world)
+
+        # Compute the source-to-target transformation
+        source_to_target = target_to_world @ world_to_source
+
+        # Convert the result to a list and round values
+        result_list = source_to_target.tolist()
+        rounded_result = [[round(value, mantissa) for value in row] for row in result_list]
+
+        return rounded_result
+
     @staticmethod
     def ByRotation(angleX=0, angleY=0, angleZ=0, order="xyz"):
         def rotateXMatrix(radians):

topologicpy/Topology.py

@@ -1498,6 +1498,8 @@ class Topology():
         edges = [e for e in edges if e]
         faces = [f for f in faces if f]
 
+        return_topology = None
+
         if not vertices:
             return None
 
@@ -1527,7 +1529,7 @@ class Topology():
         if topologyType == "wire" and edges:
             topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
             if topEdges:
-                returnTopology = topologyByEdges(topEdges, topologyType)
+                return_topology = topologyByEdges(topEdges, topologyType)
         elif faces:
             for aFace in faces:
                 faceEdges = [Edge.ByVertices([topVerts[aFace[i]], topVerts[aFace[i + 1]]], tolerance=tolerance) for i in range(len(aFace) - 1)]
@@ -1545,14 +1547,14 @@ class Topology():
                     except:
                         pass
             if topFaces:
-                returnTopology = topologyByFaces(topFaces, topologyType=topologyType, tolerance=tolerance)
+                return_topology = topologyByFaces(topFaces, topologyType=topologyType, tolerance=tolerance)
         elif edges:
             topEdges = [Edge.ByVertices([topVerts[e[0]], topVerts[e[1]]], tolerance=tolerance) for e in edges]
             if topEdges:
-                returnTopology = topologyByEdges(topEdges, topologyType)
+                return_topology = topologyByEdges(topEdges, topologyType)
         else:
-            returnTopology = Cluster.ByTopologies(topVerts)
-        return returnTopology
+            return_topology = Cluster.ByTopologies(topVerts)
+        return return_topology
     
     @staticmethod
     def ByBIMPath(path, guidKey: str = "guid", colorKey: str = "color", typeKey: str = "type",
@@ -6264,7 +6266,7 @@ class Topology():
     @staticmethod
     def IsSimilar(topologyA, topologyB, removeCoplanarFaces: bool = False, mantissa: int = 6, epsilon: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
-        Returns True if the input topologies are similar. False otherwise. See https://en.wikipedia.org/wiki/Similarity_(geometry).
+        Calculates if the input topologies are similar. See https://en.wikipedia.org/wiki/Similarity_(geometry).
 
         Parameters
         ----------
@@ -6286,7 +6288,8 @@ class Topology():
         Returns
         -------
         [bool, list]
-            True if the input topologies are similar., False otherwise and the matrix needed to tranform topologyA to match topologyB
+            True if the input topologies are similar, False otherwise and the matrix needed to tranform topologyA to match topologyB.
+            If the topologies are not similar, the transformation matrix is None.
 
         """
         from topologicpy.Vertex import Vertex
@@ -6308,7 +6311,6 @@ class Topology():
         if removeCoplanarFaces == True:
             topologyA = Topology.RemoveCoplanarFaces(topologyA, epsilon=epsilon, tolerance=tolerance)
             topologyB = Topology.RemoveCoplanarFaces(topologyB, epsilon=epsilon, tolerance=tolerance)
-        Topology.Show(topologyA, topologyB)
         len_vertices_a = len(Topology.Vertices(topologyA))
         if len_vertices_a < 1 and not Topology.IsInstance(topologyA, "vertex"):
             if not silent:
@@ -6398,90 +6400,58 @@ class Topology():
         if len(faces_a) > 0 and len(faces_b) > 0:
             largest_faces_a = Topology.LargestFaces(topologyA)
             largest_faces_b = Topology.LargestFaces(topologyB)
-
+        else:
+            if not silent:
+                print("Topology.IsSimilar - Error: The topologies do not have faces. Returning None.")
+            return False, None
 
     # Process largest faces
-        largest_faces_a = Topology.LargestFaces(topologyA)
-        largest_faces_b = Topology.LargestFaces(topologyB)
-        face_a_d = Dictionary.ByKeyValue("faceColor", "red")
-        face_b_d = Dictionary.ByKeyValue("faceColor", "blue")
         for face_a in largest_faces_a:
+            l_edge_a = Topology.LongestEdges(face_a)[0]
+            length_a = Edge.Length(l_edge_a)
             centroid_a = Topology.Centroid(face_a)
-            normal_a = Face.Normal(face_a)
+            origin_a = Vertex.Coordinates(centroid_a)
+            zaxis_a = Face.Normal(face_a)
             third_vertex_a = Face.ThirdVertex(face_a)  # Pick a third vertex for orientation
-            orientation_a = Vector.Normalize(Vector.ByVertices(centroid_a, third_vertex_a))
+            xaxis_a = Vector.Normalize(Vector.ByVertices(centroid_a, third_vertex_a))
+            yaxis_a = Vector.Cross(xaxis_a, zaxis_a)
+            # Build Coordinate System matrix. The origin will be (0,0,0) once the trans matrix is applied.
+            cs_a = [[0,0,0]]+[xaxis_a]+[yaxis_a]+[zaxis_a]
+            tran_matrix_a = Matrix.ByTranslation(translateX=-origin_a[0], translateY=-origin_a[1], translateZ=-origin_a[2])
 
+            # Check against the faces of B:
             for face_b in largest_faces_b:
-                face_copy_b = Topology.SetDictionary(Topology.Copy(face_b), face_b_d)
+                l_edge_b = Topology.LongestEdges(face_b)[0]
+                length_b = Edge.Length(l_edge_b)
+                scale_factor = length_b/length_a
+                scale_matrix = Matrix.ByScaling(scaleX=scale_factor, scaleY=scale_factor, scaleZ=scale_factor)
                 centroid_b = Topology.Centroid(face_b)
-                normal_b = Face.Normal(face_b)
+                origin_b = Vertex.Coordinates(centroid_b)
+                zaxis_b = Face.Normal(face_b)
                 third_vertex_b = Face.ThirdVertex(face_b)
-                orientation_b = Vector.Normalize(Vector.ByVertices(centroid_b, third_vertex_b))
-
+                xaxis_b = Vector.Normalize(Vector.ByVertices(centroid_b, third_vertex_b))
+                yaxis_b = Vector.Cross(xaxis_b, zaxis_b)
+                cs_b = [origin_b]+[xaxis_b]+[yaxis_b]+[zaxis_b]
                 # Compute transformation matrix
-                rotation_matrix = Matrix.ByVectors(normal_a, normal_b, orientation_a, orientation_b)
-                scaling_factor = (Face.Area(face_b) / Face.Area(face_a)) ** (1/2)
-                scaling_matrix = Matrix.ByScaling(scaling_factor, scaling_factor, scaling_factor)
-                
-                translation_matrix = Matrix.ByTranslation(
-                    Vertex.X(centroid_b) - Vertex.X(centroid_a),
-                    Vertex.Y(centroid_b) - Vertex.Y(centroid_a),
-                    Vertex.Z(centroid_b) - Vertex.Z(centroid_a)
-                )
-                combined_matrix = Matrix.Multiply(rotation_matrix, scaling_matrix)
-                combined_matrix = Matrix.Multiply(translation_matrix, combined_matrix)
-                
-                transformed_centroid_a = Topology.Transform(centroid_a, combined_matrix)
-
-                # One last translation to synchronise the two centroids.
-                translation_matrix = Matrix.ByTranslation(
-                    Vertex.X(centroid_b) - Vertex.X(transformed_centroid_a),
-                    Vertex.Y(centroid_b) - Vertex.Y(transformed_centroid_a),
-                    Vertex.Z(centroid_b) - Vertex.Z(transformed_centroid_a)
-                )
-                combined_matrix = Matrix.Multiply(translation_matrix, combined_matrix)
+                # translate to origin, scale, then transform coordinate systems
+                combined_matrix = Matrix.Multiply(scale_matrix, tran_matrix_a)
+                matching_matrix = Matrix.ByCoordinateSystems(cs_a, cs_b)
+                combined_matrix = Matrix.Multiply(matching_matrix, combined_matrix)
                 # Apply transformation and compare
-                transformedA = Topology.Transform(topologyA, combined_matrix)
-                transformed_face_a = Topology.Transform(face_a, combined_matrix)
-                transformed_face_a = Topology.SetDictionary(face_a, face_a_d)
-
-                Topology.Show(transformedA, topologyB, transformed_face_a, face_copy_b, faceColorKey="faceColor", vertexSizeKey="vertexSize")
-                if Topology.IsVertexCongruent(transformedA, topologyB, mantissa=mantissa, epsilon=epsilon, tolerance=tolerance, silent=silent):
-                    return True, combined_matrix
+                try:
+                    transformedA = Topology.Transform(topologyA, combined_matrix)
+                    status = Topology.IsVertexCongruent(transformedA, topologyB, mantissa=mantissa, epsilon=epsilon, tolerance=tolerance, silent=silent)
+                    if status:
+                        return True, combined_matrix
+                except:
+                    pass
 
         return False, None
-        # for l_f_a in largest_faces_a:
-        #     l_e_a = Face.NormalEdge(l_f_a)
-        #     centroid_a = Edge.StartVertex(l_e_a)
-        #     dir_a = Vector.Normalize(Edge.Direction(l_e_a))
-        #     trans_matrix_a = Matrix.ByTranslation(-Vertex.X(centroid_a), -Vertex.Y(centroid_a), -Vertex.Z(centroid_a))
-        #     sf_a = 1/Face.Area(l_f_a)
-        #     scaling_matrix_a = Matrix.ByScaling(sf_a, sf_a, sf_a)
-        #     for l_f_b in largest_faces_b:
-        #         l_e_b = Face.NormalEdge(l_f_b)
-        #         centroid_b = Edge.StartVertex(l_e_b)
-        #         dir_b = Vector.Normalize(Edge.Direction(l_e_b))
-        #         rotation_matrix = Matrix.ByVectors(dir_a, dir_b)
-        #         sf_b = 1/Face.Area(l_f_b)
-        #         scaling_matrix_b = Matrix.ByScaling(sf_b, sf_b, sf_b)
-        #         trans_matrix_b = Matrix.ByTranslation(-Vertex.X(centroid_b), -Vertex.Y(centroid_b), -Vertex.Z(centroid_b))
-        #         combined_matrix_a = Matrix.Multiply(rotation_matrix, scaling_matrix_a)
-        #         combined_matrix_a = Matrix.Multiply(combined_matrix_a, trans_matrix_a)
-        #         combined_matrix_b = Matrix.Multiply(scaling_matrix_b, trans_matrix_b)
-        #         top_a = Topology.Transform(topologyA, combined_matrix_a)
-        #         top_b = Topology.Transform(topologyB, combined_matrix_b)
-        #         Topology.Show(top_a, top_b)
-        #         if Topology.IsVertexCongruent(top_a, top_b, mantissa=mantissa, epsilon=epsilon, tolerance=tolerance, silent=silent):
-        #             Topology.Show(top_a, top_b)
-        #             final_matrix = Matrix.Multiply(Matrix.Invert(combined_matrix_b), combined_matrix_a)
-        #             return True, final_matrix
 
-        return False, None
- 
     @staticmethod
     def IsVertexCongruent(topologyA, topologyB, mantissa: int = 6, epsilon: float = 0.1, tolerance: float = 0.0001, silent : bool = False):
         """
-        Returns True if the input topologies are vertex matched (have same number of vertices and all vertices are congruent within a tolerance). Returns False otherwise.
+        Returns True if the input topologies are vertex congruent (have same number of vertices and all vertices are congruent within a tolerance). Returns False otherwise.
 
         Parameters
         ----------
@@ -6491,6 +6461,9 @@ class Topology():
             The second input topology.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        epsilon : float , optional
+            The desired accepted tolerance for the number of matched number of vertices. For example, an epsilon of 0.1 indicates that
+            the algorithm will return True even if 10% of the vertices do not match. The default is 0.1.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         silent : bool , optional
@@ -6504,7 +6477,7 @@ class Topology():
         """
         from topologicpy.Vertex import Vertex
 
-        def coordinates_unmatched_ratio(list1, list2, tolerance):
+        def coordinates_unmatched_ratio(list1, list2, mantissa, tolerance):
             """
             Calculates the percentage of coordinates in list1 that do not have a corresponding
             coordinate in list2 within a specified tolerance, with each match being unique.
@@ -6543,7 +6516,7 @@ class Topology():
             total_coordinates = len(list1)
             unmatched_ratio = (unmatched_count / total_coordinates)
             
-            return unmatched_ratio
+            return round(unmatched_ratio, mantissa)
 
         if not Topology.IsInstance(topologyA, "topology"):
             if not silent:
@@ -6568,11 +6541,12 @@ class Topology():
             return None
         # Number of vertices
         max_len = max([len_vertices_a, len_vertices_b])
-        if abs(len_vertices_a - len_vertices_a)/max_len >= epsilon:
+        ratio = round(float(abs(len_vertices_a - len_vertices_b))/float(max_len), mantissa)
+        if ratio > epsilon:
             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]
-        unmatched_ratio = coordinates_unmatched_ratio(coords_a, coords_b, tolerance=tolerance)
+        unmatched_ratio = coordinates_unmatched_ratio(coords_a, coords_b, mantissa=mantissa, tolerance=tolerance)
         if unmatched_ratio <= epsilon:
             return True
         return False

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.14'
+__version__ = '0.8.15'

{topologicpy-0.8.14.dist-info → topologicpy-0.8.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: topologicpy
-Version: 0.8.14
+Version: 0.8.15
 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.14.dist-info → topologicpy-0.8.15.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=1q2lR5eDs7Wnwv7M-Kr7Cj3GG_iy7d1ddaZqWGHdX-w,12932
-topologicpy/Cell.py,sha256=DYVXGfzioMBsQOkrP-BhJ5iHExKhTGAxOhMlmWeG4vw,118262
+topologicpy/Cell.py,sha256=BN6hjYpN6Fse0mn7d7oHh65D7c6Mt1Yu7iK3lEp_Cj0,118262
 topologicpy/CellComplex.py,sha256=udDzbMub3d2QYn1XGMzt3F9Su2VXuAGvn0eoTtOIn3g,58207
 topologicpy/Cluster.py,sha256=o5jdMRpcGfSGGiXQdFg-e9XcnBF5AqTj3xb1nSpwJWE,58606
 topologicpy/Color.py,sha256=q9xsGmxFMz7sQKmygwSVS12GaTRB-OT0-_i6t3-cthE,20307
@@ -15,7 +15,7 @@ topologicpy/Graph.py,sha256=FBmiMObzztPwZFJ2T846Ivz0Y1kpzMF0sF-PDUMPk4o,498946
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
 topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
-topologicpy/Matrix.py,sha256=mqcCk14kM9OOwJPwd9ce-8SFM0IxS3jYb2XpWhVjUAc,19503
+topologicpy/Matrix.py,sha256=i22RLP5ebUAMuU7V1tZ__Z4lf1pg9fzq9nENsDZUV74,22779
 topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
 topologicpy/Plotly.py,sha256=RU_VioIRLGIYzwyKI9OQHOx9OxxGppdpagysgTbdxIE,115942
 topologicpy/Polyskel.py,sha256=DDUayC29LI1EkxdK09F0DgGyH-NCOU1LE3J2Imz0rEI,19832
@@ -23,14 +23,14 @@ topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=--dJoSdz6BapxVEyG2DI0W5apO_xwLORj5qmR15yl2Y,87983
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=mhRKJlFJLe_IGxj_bQ5lbK277YKod7PLXWzZ2Suq8ng,465493
+topologicpy/Topology.py,sha256=O91rRl32hG3YvKowSDGbxaq3zdM16RIChT4HF9hNODM,463786
 topologicpy/Vector.py,sha256=GkGt-aJ591IJ2IPffMAudvITLDPi2qZibZc4UAav6m8,42407
 topologicpy/Vertex.py,sha256=xr8KSgKnx-hgVp-eIvMPAKRv04R-wk-_4zc57xVyEqE,80793
 topologicpy/Wire.py,sha256=x7tOeR1o5qi5cXp_d9JrQrSXfYztCWiBC1OnVl6Yp7A,228463
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=Lw9k1hHakMjGPEzEp8wU2hEIGzA0_SHXmAYeLmbM_Kg,23
-topologicpy-0.8.14.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.14.dist-info/METADATA,sha256=HVOo7iDJt80dFu4DEf_0H0du_Zq8rCW2WFLikjwb7HU,10513
-topologicpy-0.8.14.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.14.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.14.dist-info/RECORD,,
+topologicpy/version.py,sha256=HbO2F5YBMLHRpphNJizV3_Sp8T0xTu3xaqHhjkNWPRc,23
+topologicpy-0.8.15.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.15.dist-info/METADATA,sha256=ft8T8ED9kou73cq52cvDshxjosXDKXdtXLqososiUNM,10513
+topologicpy-0.8.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+topologicpy-0.8.15.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.15.dist-info/RECORD,,