topologicpy 0.8.13__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:
@@ -2185,62 +2185,154 @@ class Cell():
         return Cell.Area(cell=cell, mantissa=mantissa)
     
     @staticmethod
-    def Tetrahedron(origin= None, radius: float = 0.5,
-                  direction: list = [0, 0, 1], placement: str ="center", tolerance: float = 0.0001):
+    def Tetrahedron(origin = None, length: float = 1, depth: int = 1, direction=[0,0,1], placement="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-        Creates a tetrahedron. See https://en.wikipedia.org/wiki/Tetrahedron.
+        Creates a recursive tetrahedron cell.
 
         Parameters
         ----------
         origin : topologic_core.Vertex , optional
             The origin location of the tetrahedron. The default is None which results in the tetrahedron being placed at (0, 0, 0).
-        radius : float , optional
-            The radius of the tetrahedron's circumscribed sphere. The default is 0.5.
+        length : float , optional
+            The length of the edge of the tetrahedron. The default is 1.
+        depth : int , optional
+            The desired maximum number of recrusive subdivision levels.
         direction : list , optional
             The vector representing the up direction of the tetrahedron. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the tetrahedron. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         
         Returns
         -------
-        topologic_core.Cell
+        topologic_core.CellComplex
             The created tetrahedron.
 
         """
-        
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
-        import math
+        from topologicpy.Dictionary import Dictionary
 
-        if not Topology.IsInstance(origin, "Vertex"):
-            origin = Vertex.ByCoordinates(0, 0, 0)
-        if not Topology.IsInstance(origin, "Vertex"):
-            print("Cell.Tetrahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
-            return None
+        from math import sqrt
 
-        vb1 = Vertex.ByCoordinates(math.sqrt(8/9), 0, -1/3)
-        vb2 = Vertex.ByCoordinates(-math.sqrt(2/9), math.sqrt(2/3), -1/3)
-        vb3 = Vertex.ByCoordinates(-math.sqrt(2/9), -math.sqrt(2/3), -1/3)
-        vb4 = Vertex.ByCoordinates(0, 0, 1)
-        f1 = Face.ByVertices([vb1, vb2, vb3])
-        f2 = Face.ByVertices([vb4, vb1, vb2])
-        f3 = Face.ByVertices([vb4, vb2, vb3])
-        f4 = Face.ByVertices([vb4, vb3, vb1])
-        tetrahedron = Cell.ByFaces([f1, f2, f3, f4])
-        tetrahedron = Topology.Scale(tetrahedron, origin=Vertex.Origin(), x=0.5, y=0.5, z=0.5)
-        tetrahedron = Topology.Scale(tetrahedron, origin=Vertex.Origin(), x=radius/0.5, y=radius/0.5, z=radius/0.5)
+        def subdivide_tetrahedron(tetrahedron, depth):
+            """
+            Recursively subdivides a tetrahedron into smaller tetrahedra.
 
-        if placement.lower() == "lowerleft":
-            tetrahedron = Topology.Translate(tetrahedron, radius, radius, radius)
+            Parameters:
+                tetrahedron (Cell): The tetrahedron to subdivide.
+                depth (int): Recursion depth for the subdivision.
+
+            Returns:
+                list: List of smaller tetrahedral cells.
+            """
+            if depth == 0:
+                return [tetrahedron]
+
+            # Extract the vertices of the tetrahedron
+            vertices = Topology.Vertices(tetrahedron)
+            v0, v1, v2, v3 = vertices
+
+            # Calculate midpoints of the edges
+            m01 = Vertex.ByCoordinates((v0.X() + v1.X()) / 2, (v0.Y() + v1.Y()) / 2, (v0.Z() + v1.Z()) / 2)
+            m02 = Vertex.ByCoordinates((v0.X() + v2.X()) / 2, (v0.Y() + v2.Y()) / 2, (v0.Z() + v2.Z()) / 2)
+            m03 = Vertex.ByCoordinates((v0.X() + v3.X()) / 2, (v0.Y() + v3.Y()) / 2, (v0.Z() + v3.Z()) / 2)
+            m12 = Vertex.ByCoordinates((v1.X() + v2.X()) / 2, (v1.Y() + v2.Y()) / 2, (v1.Z() + v2.Z()) / 2)
+            m13 = Vertex.ByCoordinates((v1.X() + v3.X()) / 2, (v1.Y() + v3.Y()) / 2, (v1.Z() + v3.Z()) / 2)
+            m23 = Vertex.ByCoordinates((v2.X() + v3.X()) / 2, (v2.Y() + v3.Y()) / 2, (v2.Z() + v3.Z()) / 2)
+
+            # Create smaller tetrahedra
+            tetrahedra = [
+                Cell.ByFaces([
+                    Face.ByVertices([v0, m01, m02]),
+                    Face.ByVertices([v0, m01, m03]),
+                    Face.ByVertices([v0, m02, m03]),
+                    Face.ByVertices([m01, m02, m03])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m01, v1, m12]),
+                    Face.ByVertices([m01, v1, m13]),
+                    Face.ByVertices([m01, m12, m13]),
+                    Face.ByVertices([v1, m12, m13])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m02, m12, v2]),
+                    Face.ByVertices([m02, m12, m23]),
+                    Face.ByVertices([m02, v2, m23]),
+                    Face.ByVertices([m12, v2, m23])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m03, m13, m23]),
+                    Face.ByVertices([m03, v3, m13]),
+                    Face.ByVertices([m03, v3, m23]),
+                    Face.ByVertices([m13, v3, m23])
+                ])
+            ]
+
+            # Recursively subdivide the smaller tetrahedra
+            result = []
+            for t in tetrahedra:
+                result.extend(subdivide_tetrahedron(t, depth - 1))
+            return result
+
+        if not Topology.IsInstance(origin, "vertex"):
+            origin = Vertex.Origin()
+        
+        # Define the four vertices of the tetrahedron
+        v0 = Vertex.ByCoordinates(0, 0, 0)
+        v1 = Vertex.ByCoordinates(length, 0, 0)
+        v2 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length, 0)
+        v3 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length/3, sqrt(2/3)*length)
+
+        # Create the initial tetrahedron
+        tetrahedron = Cell.ByFaces([
+            Face.ByVertices([v0, v1, v2]),
+            Face.ByVertices([v0, v1, v3]),
+            Face.ByVertices([v1, v2, v3]),
+            Face.ByVertices([v2, v0, v3]),
+        ])
+
+        bbox = Topology.BoundingBox(tetrahedron)
+        d = Topology.Dictionary(bbox)
+        bb_width = Dictionary.ValueAtKey(d, "width")
+        bb_length = Dictionary.ValueAtKey(d, "length")
+        bb_height = Dictionary.ValueAtKey(d, "height")
+        
+        centroid = Topology.Centroid(tetrahedron)
+        c_x, c_y, c_z = Vertex.Coordinates(centroid, mantissa=mantissa)
+
+        if placement.lower() == "center":
+            tetrahedron = Topology.Translate(tetrahedron, -c_x, -c_y, -c_z)
         elif placement.lower() == "bottom":
-            tetrahedron = Topology.Translate(tetrahedron, 0, 0, radius)
-        tetrahedron = Topology.Place(tetrahedron, originA=Vertex.Origin(), originB=origin)
-        tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0, 0, 1], dirB=direction, tolerance=tolerance)
-        return tetrahedron
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, 0)
+        elif placement.lower() == "upperleft":
+            tetrahedron = Topology.Translate(tetrahedron, 0, 0, -bb_height)
+        elif placement.lower() == "upperright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, -bb_height)
+        elif placement.lower() == "bottomright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, 0)
+        elif placement.lower() == "top":
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, -bb_height)
+        
+        tetrahedron = Topology.Place(tetrahedron, Vertex.Origin(), origin)
+        if not direction == [0,0,1]:
+            tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0,0,1], dirB=direction)
+
+        depth = max(depth, 0)
+        if depth == 0:
+            return tetrahedron
+        else:
+            # Recursively subdivide the tetrahedron
+            subdivided_tetrahedra = subdivide_tetrahedron(tetrahedron, depth)
+            # Create a cell complex from the subdivided tetrahedra
+            return CellComplex.ExternalBoundary(CellComplex.ByCells([tetrahedron]+subdivided_tetrahedra))
     
     @staticmethod
     def Torus(origin= None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):

topologicpy/CellComplex.py

@@ -1012,6 +1012,151 @@ class CellComplex():
         shells = Topology.Shells(cellComplex)
         return shells
 
+    @staticmethod
+    def Tetrahedron(origin = None, length: float = 1, depth: int = 1, direction=[0,0,1], placement="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Creates a recursive tetrahedron cellComplex with internal cells.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the tetrahedron. The default is None which results in the tetrahedron being placed at (0, 0, 0).
+        length : float , optional
+            The length of the edge of the tetrahedron. The default is 1.
+        depth : int , optional
+            The desired maximum number of recrusive subdivision levels.
+        direction : list , optional
+            The vector representing the up direction of the tetrahedron. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the tetrahedron. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.CellComplex
+            The created tetrahedron.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        from math import sqrt
+
+        def subdivide_tetrahedron(tetrahedron, depth):
+            """
+            Recursively subdivides a tetrahedron into smaller tetrahedra.
+
+            Parameters:
+                tetrahedron (Cell): The tetrahedron to subdivide.
+                depth (int): Recursion depth for the subdivision.
+
+            Returns:
+                list: List of smaller tetrahedral cells.
+            """
+            if depth == 0:
+                return [tetrahedron]
+
+            # Extract the vertices of the tetrahedron
+            vertices = Topology.Vertices(tetrahedron)
+            v0, v1, v2, v3 = vertices
+
+            # Calculate midpoints of the edges
+            m01 = Vertex.ByCoordinates((v0.X() + v1.X()) / 2, (v0.Y() + v1.Y()) / 2, (v0.Z() + v1.Z()) / 2)
+            m02 = Vertex.ByCoordinates((v0.X() + v2.X()) / 2, (v0.Y() + v2.Y()) / 2, (v0.Z() + v2.Z()) / 2)
+            m03 = Vertex.ByCoordinates((v0.X() + v3.X()) / 2, (v0.Y() + v3.Y()) / 2, (v0.Z() + v3.Z()) / 2)
+            m12 = Vertex.ByCoordinates((v1.X() + v2.X()) / 2, (v1.Y() + v2.Y()) / 2, (v1.Z() + v2.Z()) / 2)
+            m13 = Vertex.ByCoordinates((v1.X() + v3.X()) / 2, (v1.Y() + v3.Y()) / 2, (v1.Z() + v3.Z()) / 2)
+            m23 = Vertex.ByCoordinates((v2.X() + v3.X()) / 2, (v2.Y() + v3.Y()) / 2, (v2.Z() + v3.Z()) / 2)
+
+            # Create smaller tetrahedra
+            tetrahedra = [
+                Cell.ByFaces([
+                    Face.ByVertices([v0, m01, m02]),
+                    Face.ByVertices([v0, m01, m03]),
+                    Face.ByVertices([v0, m02, m03]),
+                    Face.ByVertices([m01, m02, m03])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m01, v1, m12]),
+                    Face.ByVertices([m01, v1, m13]),
+                    Face.ByVertices([m01, m12, m13]),
+                    Face.ByVertices([v1, m12, m13])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m02, m12, v2]),
+                    Face.ByVertices([m02, m12, m23]),
+                    Face.ByVertices([m02, v2, m23]),
+                    Face.ByVertices([m12, v2, m23])
+                ]),
+                Cell.ByFaces([
+                    Face.ByVertices([m03, m13, m23]),
+                    Face.ByVertices([m03, v3, m13]),
+                    Face.ByVertices([m03, v3, m23]),
+                    Face.ByVertices([m13, v3, m23])
+                ])
+            ]
+
+            # Recursively subdivide the smaller tetrahedra
+            result = []
+            for t in tetrahedra:
+                result.extend(subdivide_tetrahedron(t, depth - 1))
+            return result
+
+        if not Topology.IsInstance(origin, "vertex"):
+            origin = Vertex.Origin()
+        
+        # Define the four vertices of the tetrahedron
+        v0 = Vertex.ByCoordinates(0, 0, 0)
+        v1 = Vertex.ByCoordinates(length, 0, 0)
+        v2 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length, 0)
+        v3 = Vertex.ByCoordinates(length/2, sqrt(3)/2*length/3, sqrt(2/3)*length)
+
+        # Create the initial tetrahedron
+        tetrahedron = Cell.ByFaces([
+            Face.ByVertices([v0, v1, v2]),
+            Face.ByVertices([v0, v1, v3]),
+            Face.ByVertices([v1, v2, v3]),
+            Face.ByVertices([v2, v0, v3]),
+        ])
+
+        bbox = Topology.BoundingBox(tetrahedron)
+        d = Topology.Dictionary(bbox)
+        bb_width = Dictionary.ValueAtKey(d, "width")
+        bb_length = Dictionary.ValueAtKey(d, "length")
+        bb_height = Dictionary.ValueAtKey(d, "height")
+        
+        centroid = Topology.Centroid(tetrahedron)
+        c_x, c_y, c_z = Vertex.Coordinates(centroid, mantissa=mantissa)
+
+        if placement.lower() == "center":
+            tetrahedron = Topology.Translate(tetrahedron, -c_x, -c_y, -c_z)
+        elif placement.lower() == "bottom":
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, 0)
+        elif placement.lower() == "upperleft":
+            tetrahedron = Topology.Translate(tetrahedron, 0, 0, -bb_height)
+        elif placement.lower() == "upperright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, -bb_height)
+        elif placement.lower() == "bottomright":
+            tetrahedron = Topology.Translate(tetrahedron, -bb_width, -bb_length, 0)
+        elif placement.lower() == "top":
+            tetrahedron = Topology.Translate(tetrahedron,-c_x, -c_y, -bb_height)
+        
+        tetrahedron = Topology.Place(tetrahedron, Vertex.Origin(), origin)
+        if not direction == [0,0,1]:
+            tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0,0,1], dirB=direction)
+
+        depth = max(depth, 1)
+        # Recursively subdivide the tetrahedron
+        subdivided_tetrahedra = subdivide_tetrahedron(tetrahedron, depth)
+        # Create a cell complex from the subdivided tetrahedra
+        return CellComplex.ByCells([tetrahedron]+subdivided_tetrahedra)
+    
     @staticmethod
     def Torus(origin= None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
         """

topologicpy/Honeybee.py

@@ -300,33 +300,27 @@ class Honeybee:
         sensorGrids = []
         for spaceNumber, tpCell in enumerate(tpCells):
             tpDictionary = Topology.Dictionary(tpCell)
-            tpCellName = None
-            tpCellStory = None
+            tpCellName = "Untitled Space"
+            tpCellStory = fl[0]
             tpCellProgramIdentifier = None
             tpCellConstructionSetIdentifier = None
             tpCellConditioned = True
             if tpDictionary:
                 keyName = getKeyName(tpDictionary, 'Story')
-                try:
-                    tpCellStory = Dictionary.ValueAtKey(tpDictionary, keyName)
-                    if tpCellStory:
-                        tpCellStory = tpCellStory.replace(" ","_")
-                except:
-                    tpCellStory = fl[spaceNumber]
+                tpCellStory = Dictionary.ValueAtKey(tpDictionary, keyName, silent=True) or fl[spaceNumber]
+                if tpCellStory:
+                    tpCellStory = tpCellStory.replace(" ","_")
+                else:
+                    tpCellStory = "Untitled_Floor"
                 if roomNameKey:
                     keyName = getKeyName(tpDictionary, roomNameKey)
                 else:
                     keyName = getKeyName(tpDictionary, 'Name')
-                try:
-                    tpCellName = Dictionary.ValueAtKey(tpDictionary,keyName)
-                    if tpCellName:
-                        tpCellName = createUniqueName(tpCellName.replace(" ","_"), spaceNames, 1)
-                except:
-                    tpCellName = tpCellStory+"_SPACE_"+(str(spaceNumber+1))
+                tpCellName = Dictionary.ValueAtKey(tpDictionary,keyName, silent=True) or createUniqueName(tpCellStory+"_SPACE_"+(str(spaceNumber+1)), spaceNames, 1)
                 if roomTypeKey:
                     keyName = getKeyName(tpDictionary, roomTypeKey)
                 try:
-                    tpCellProgramIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName)
+                    tpCellProgramIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName, silent=True)
                     if tpCellProgramIdentifier:
                         program = prog_type_lib.program_type_by_identifier(tpCellProgramIdentifier)
                     elif defaultProgramIdentifier:
@@ -335,7 +329,7 @@ class Honeybee:
                     program = prog_type_lib.office_program #Default Office Program as a last resort
                 keyName = getKeyName(tpDictionary, 'construction_set')
                 try:
-                    tpCellConstructionSetIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName)
+                    tpCellConstructionSetIdentifier = Dictionary.ValueAtKey(tpDictionary, keyName, silent=True)
                     if tpCellConstructionSetIdentifier:
                         constr_set = constr_set_lib.construction_set_by_identifier(tpCellConstructionSetIdentifier)
                     elif defaultConstructionSetIdentifier:
@@ -344,7 +338,7 @@ class Honeybee:
                     constr_set = constr_set_lib.construction_set_by_identifier("Default Generic Construction Set")
             else:
                 tpCellStory = fl[spaceNumber]
-                tpCellName = tpCellStory+"_SPACE_"+(str(spaceNumber+1))
+                tpCellName = str(tpCellStory)+"_SPACE_"+(str(spaceNumber+1))
                 program = prog_type_lib.office_program
                 constr_set = constr_set_lib.construction_set_by_identifier("Default Generic Construction Set")
             spaceNames.append(tpCellName)
@@ -366,7 +360,7 @@ class Honeybee:
                             tpFaceApertureDictionary = Topology.Dictionary(apertureTopology)
                             if tpFaceApertureDictionary:
                                 apertureKeyName = getKeyName(tpFaceApertureDictionary, apertureTypeKey)
-                                tpFaceApertureType = Dictionary.ValueAtKey(tpFaceApertureDictionary,apertureKeyName)
+                                tpFaceApertureType = Dictionary.ValueAtKey(tpFaceApertureDictionary,apertureKeyName, silent=True)
                             hbFaceAperturePoints = []
                             tpFaceApertureVertices = []
                             tpFaceApertureVertices = Topology.Vertices(Face.ExternalBoundary(apertureTopology))
@@ -383,7 +377,7 @@ class Honeybee:
                     else:
                         tpFaceDictionary = Topology.Dictionary(tpCellFace)
                         if (abs(tpCellFaceNormal[2]) < 1e-6) and tpFaceDictionary: #It is a mostly vertical wall and has a dictionary
-                            apertureRatio = Dictionary.ValueAtKey(tpFaceDictionary,'apertureRatio')
+                            apertureRatio = Dictionary.ValueAtKey(tpFaceDictionary,'apertureRatio', silent=True)
                             if apertureRatio:
                                 hbRoomFace.apertures_by_ratio(apertureRatio, tolerance=0.01)
                     fType = honeybee.facetype.get_type_from_normal(Vector3D(tpCellFaceNormal[0],tpCellFaceNormal[1],tpCellFaceNormal[2]), roof_angle=30, floor_angle=150)

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.13'
+__version__ = '0.8.15'

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: topologicpy
-Version: 0.8.13
+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.13.dist-info → topologicpy-0.8.15.dist-info}/RECORD

@@ -1,8 +1,8 @@
 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=Wwr2RsNEagfdt4Uz0GYosRTgNQj0pc5NOlzEWbL7cjQ,114343
-topologicpy/CellComplex.py,sha256=23bO0RYFIg6MOyt3PMFayaK523Alt8aHhc6UyJO02X0,51610
+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
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
@@ -14,8 +14,8 @@ topologicpy/Face.py,sha256=tn3PI-t9rXikgI1QMclw0PFwQ5vvyLi-wJKqZZZ9xmw,182755
 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=Y_El6M8x3ixvvIe_VcRiwj_4C89ZZg5_WlT7adbCkpw,21849
-topologicpy/Matrix.py,sha256=mqcCk14kM9OOwJPwd9ce-8SFM0IxS3jYb2XpWhVjUAc,19503
+topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
+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=XjaqL6H5ZzfJyu62UXI4UhwezcxfWWIh4nGQ9YuybtM,23
-topologicpy-0.8.13.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.13.dist-info/METADATA,sha256=5SZpCgIN0s9DGq8P0heNOhibtizlRvUZIb2fP0gJAtE,10513
-topologicpy-0.8.13.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-topologicpy-0.8.13.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.13.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,,