topologicpy 0.8.26__py3-none-any.whl → 0.8.29__py3-none-any.whl

topologicpy/Face.py

@@ -1927,6 +1927,34 @@ class Face():
         else:
             inverted_face = Face.ByWires(inverted_wire, internal_boundaries, tolerance=tolerance)
         return inverted_face
+    @staticmethod
+    def IsConvex(face, mantissa: int = 6, silent: bool = False) -> bool:
+        """
+        Returns True if the input face is convex. Returns False otherwise.
+
+        Parameters
+        ----------
+        face : topologic_core.Face
+            The  input face.
+        mantissa : int , optional
+            The length of the desired mantissa. The default is 6.
+        silent : bool , optional
+            If set to True no warnings or errors are printed. The default is False.
+        Returns
+        -------
+        bool
+            True if the nput face is convex. False otherwise.
+
+        """
+        from topologicpy.Topology import Topology
+        
+        if not Topology.IsInstance(face, "face"):
+            if not silent:
+                print("Face.IsConvex - Error: The input face parameter is not a valid topologic face. Returning None.")
+            return None
+        eb = Face.ExternalBoundary(face)
+        eb = Face.ByWire(eb)
+        return all(Face.InteriorAngles(eb)) < 180
 
     @staticmethod
     def IsCoplanar(faceA, faceB, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
@@ -2468,9 +2496,9 @@ class Face():
             flat_face = Topology.Difference(flat_face, Face.ByWire(obs))
         
         # Check that the viewpoint is inside the face
-        if not Vertex.IsInternal(flat_vertex, flat_face):
-            print("Face.Isovist - Error: The viewpoint is not inside the face. Returning None.")
-            return None
+        # if not Vertex.IsInternal(flat_vertex, flat_face):
+        #     print("Face.Isovist - Error: The viewpoint is not inside the face. Returning None.")
+        #     return None
         targets = Topology.Vertices(flat_face)
         distances = []
         for target in targets:
@@ -3544,7 +3572,7 @@ class Face():
         return Face.ByWire(wire, tolerance=tolerance)
 
     @staticmethod
-    def Triangulate(face, mode: int = 0, meshSize: float = None, mantissa: int = 6, tolerance: float = 0.0001) -> list:
+    def Triangulate(face, mode: int = 0, meshSize: float = None, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False) -> list:
         """
         Triangulates the input face and returns a list of faces.
 
@@ -3571,6 +3599,8 @@ class Face():
             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
         -------
@@ -3638,7 +3668,8 @@ class Face():
             from topologicpy.Topology import Topology
 
             if not Topology.IsInstance(face, "Face"):
-                print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
+                if not silent:
+                    print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
                 return None
             if not meshSize:
                 bounding_face = Face.BoundingRectangle(face)
@@ -3713,7 +3744,8 @@ class Face():
             return faces
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
+            if not silent:
+                print("Face.Triangulate - Error: The input face parameter is not a valid face. Returning None.")
             return None
         vertices = Topology.Vertices(face)
         if len(vertices) == 3: # Already a triangle

topologicpy/Graph.py

@@ -2455,6 +2455,204 @@ class Graph:
 
     @staticmethod
     def ByIFCFile(file,
+                  includeTypes: list = [],
+                  excludeTypes: list = [],
+                  includeRels: list = [],
+                  excludeRels: list = [],
+                  transferDictionaries: bool = False,
+                  useInternalVertex: bool = False,
+                  storeBREP: bool = False,
+                  removeCoplanarFaces: bool = False,
+                  xMin: float = -0.5, yMin: float = -0.5, zMin: float = -0.5,
+                  xMax: float = 0.5, yMax: float = 0.5, zMax: float = 0.5,
+                  epsilon: float = 0.0001,
+                  tolerance: float = 0.0001,
+                  silent: bool = False):
+        
+        """
+        Create a Graph from an IFC file. This code is partially based on code from Bruno Postle.
+
+        Parameters
+        ----------
+        file : file
+            The input IFC file
+        includeTypes : list , optional
+            A list of IFC object types to include in the graph. The default is [] which means all object types are included.
+        excludeTypes : list , optional
+            A list of IFC object types to exclude from the graph. The default is [] which mean no object type is excluded.
+        includeRels : list , optional
+            A list of IFC relationship types to include in the graph. The default is [] which means all relationship types are included.
+        excludeRels : list , optional
+            A list of IFC relationship types to exclude from the graph. The default is [] which mean no relationship type is excluded.
+        transferDictionaries : bool , optional
+            NOT USED. If set to True, the dictionaries from the IFC file will be transferred to the topology. Otherwise, they won't. The default is False.
+        useInternalVertex : bool , optional
+            If set to True, use an internal vertex to represent the subtopology. Otherwise, use its centroid. The default is False.
+        storeBREP : bool , optional
+            If set to True, store the BRep of the subtopology in its representative vertex. The default is False.
+        removeCoplanarFaces : bool , optional
+            If set to True, coplanar faces are removed. Otherwise they are not. The default is False.
+        xMin : float, optional
+            The desired minimum value to assign for a vertex's X coordinate. The default is -0.5.
+        yMin : float, optional
+            The desired minimum value to assign for a vertex's Y coordinate. The default is -0.5.
+        zMin : float, optional
+            The desired minimum value to assign for a vertex's Z coordinate. The default is -0.5.
+        xMax : float, optional
+            The desired maximum value to assign for a vertex's X coordinate. The default is 0.5.
+        yMax : float, optional
+            The desired maximum value to assign for a vertex's Y coordinate. The default is 0.5.
+        zMax : float, optional
+            The desired maximum value to assign for a vertex's Z coordinate. The default is 0.5.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic_core.Graph
+            The created graph.
+        
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        
+        def vertex_at_key_value(vertices, key, value):
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                d_value = Dictionary.ValueAtKey(d, key)
+                if value == d_value:
+                    return v
+            return None
+        
+        def get_vertices(includeTypes=[], excludeTypes=[], removeCoplanarFaces=False, storeBREP=False, useInternalVertex=useInternalVertex, epsilon=0.0001, tolerance=0.0001):
+            # Get the topologies
+            topologies = Topology.ByIFCFile(file,
+                                            includeTypes=includeTypes,
+                                            excludeTypes=excludeTypes,
+                                        transferDictionaries=True,
+                                        removeCoplanarFaces=removeCoplanarFaces,
+                                        epsilon=epsilon,
+                                        tolerance=tolerance)
+            vertices = []
+            for topology in topologies:
+                if Topology.IsInstance(topology, "Topology"):
+                    if useInternalVertex == True:
+                        v = Topology.InternalVertex(topology)
+                    else:
+                        v = Topology.Centroid(topology)
+                    d = Topology.Dictionary(topology)
+                    if storeBREP:
+                        d = Dictionary.SetValueAtKey(d, "BREP", Topology.BREPString(topology))
+                    if Topology.IsInstance(v, "vertex"):
+                        v = Topology.SetDictionary(v, Topology.Dictionary(topology))
+                        vertices.append(v)
+                    else:
+                        if not silent:
+                            ifc_id = Dictionary.ValueAtKey(Topology.Dictionary(topology), "IFC_global_id", 0)
+                            print(f"Graph.ByIFCFile - Warning: Could not create a vertex for entity {ifc_id}. Skipping")
+            return vertices
+        
+        # Get the relationships
+        def get_relationships(ifc_file, includeRels=[], excludeRels=[]):
+            include_set = set(s.lower() for s in includeRels)
+            exclude_set = set(s.lower() for s in excludeRels)
+
+            relationships = [
+                rel for rel in ifc_file.by_type("IfcRelationship")
+                if (rel.is_a().lower() not in exclude_set) and
+                (not include_set or rel.is_a().lower() in include_set)
+            ]
+
+            return relationships
+        def get_edges(ifc_relationships, vertices):
+            tuples = []
+            edges = []
+
+            for ifc_rel in ifc_relationships:
+                source = None
+                destinations = []
+                if ifc_rel.is_a("IfcRelConnectsPorts"):
+                    source = ifc_rel.RelatingPort
+                    destinations = ifc_rel.RelatedPorts
+                elif ifc_rel.is_a("IfcRelConnectsPortToElement"):
+                    source = ifc_rel.RelatingPort
+                    destinations = [ifc_rel.RelatedElement]
+                elif ifc_rel.is_a("IfcRelAggregates"):
+                    source = ifc_rel.RelatingObject
+                    destinations = ifc_rel.RelatedObjects
+                elif ifc_rel.is_a("IfcRelNests"):
+                    source = ifc_rel.RelatingObject
+                    destinations = ifc_rel.RelatedObjects
+                elif ifc_rel.is_a("IfcRelAssignsToGroup"):
+                    source = ifc_rel.RelatingGroup
+                    destinations = ifc_rel.RelatedObjects
+                elif ifc_rel.is_a("IfcRelConnectsPathElements"):
+                    source = ifc_rel.RelatingElement
+                    destinations = [ifc_rel.RelatedElement]
+                elif ifc_rel.is_a("IfcRelConnectsStructuralMember"):
+                    source = ifc_rel.RelatingStructuralMember
+                    destinations = [ifc_rel.RelatedStructuralConnection]
+                elif ifc_rel.is_a("IfcRelContainedInSpatialStructure"):
+                    source = ifc_rel.RelatingStructure
+                    destinations = ifc_rel.RelatedElements
+                elif ifc_rel.is_a("IfcRelFillsElement"):
+                    source = ifc_rel.RelatingOpeningElement
+                    destinations = [ifc_rel.RelatedBuildingElement]
+                elif ifc_rel.is_a("IfcRelSpaceBoundary"):
+                    source = ifc_rel.RelatingSpace
+                    destinations = [ifc_rel.RelatedBuildingElement]
+                elif ifc_rel.is_a("IfcRelVoidsElement"):
+                    source = ifc_rel.RelatingBuildingElement
+                    destinations = [ifc_rel.RelatedOpeningElement]
+                elif ifc_rel.is_a("IfcRelDefinesByProperties") or ifc_rel.is_a("IfcRelAssociatesMaterial") or ifc_rel.is_a("IfcRelDefinesByType"):
+                    source = None
+                    destinations = None
+                else:
+                    print("Graph.ByIFCFile - Warning: The relationship", ifc_rel, "is not supported. Skipping.")
+                if source:
+                    sv = vertex_at_key_value(vertices, key="IFC_global_id", value=getattr(source, 'GlobalId', 0))
+                    if sv:
+                        si = Vertex.Index(sv, vertices, tolerance=tolerance)
+                        if not si == None:
+                            for destination in destinations:
+                                if destination == None:
+                                    continue
+                                ev = vertex_at_key_value(vertices, key="IFC_global_id", value=getattr(destination, 'GlobalId', 0))
+                                if ev:
+                                    ei = Vertex.Index(ev, vertices, tolerance=tolerance)
+                                    if not ei == None:
+                                        if not si == ei:
+                                            if not [si,ei] in tuples:
+                                                tuples.append([si,ei])
+                                                tuples.append([ei,si])
+                                                e = Edge.ByVertices([sv,ev])
+                                                if Topology.IsInstance(e, "edge"):
+                                                    d = Dictionary.ByKeysValues(["IFC_global_id", "IFC_name", "IFC_type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
+                                                    e = Topology.SetDictionary(e, d)
+                                                    edges.append(e)
+                                                else:
+                                                    if not silent:
+                                                        if not silent:
+                                                            print(f"Graph.ByIFCFile - Warning: Could not create an edge for relationship {ifc_rel.id()}. Skipping")
+
+            return edges
+        
+        vertices = get_vertices(includeTypes=includeTypes,
+                                excludeTypes=excludeTypes,
+                                removeCoplanarFaces=removeCoplanarFaces,
+                                storeBREP=storeBREP,
+                                useInternalVertex=useInternalVertex,
+                                epsilon=epsilon,
+                                tolerance=0.0001)
+        relationships = get_relationships(file, includeRels=includeRels, excludeRels=excludeRels)
+        edges = get_edges(relationships, vertices)
+        return Graph.ByVerticesEdges(vertices, edges)
+        
+    @staticmethod
+    def ByIFCFile_old(file,
                   includeTypes: list = [],
                   excludeTypes: list = [],
                   includeRels: list = [],

topologicpy/Grid.py

@@ -286,12 +286,11 @@ class Grid():
                     vTempVec = Vector.Multiply(uvVector, v, tolerance=tolerance)
                     gridVertex = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+uTempVec[0], Vertex.Y(origin, mantissa=mantissa)+vTempVec[1], Vertex.Z(origin, mantissa=mantissa)+uTempVec[2])
                     if clip and Topology.IsInstance(face, "Face"):
-                        gridVertex = gridVertex.Intersect(face, False)
-                    if Topology.IsInstance(gridVertex, "Vertex"):
-                        d = Dictionary.ByKeysValues(["u","v"],[u,v])
-                        if d:
-                            gridVertex.SetDictionary(d)
-                        gridVertices.append(gridVertex)
+                        if Vertex.IsInternal(gridVertex, face):
+                            d = Dictionary.ByKeysValues(["u","v"],[u,v])
+                            if d:
+                                gridVertex.SetDictionary(d)
+                    gridVertices.append(gridVertex)
         grid = None
         if len(gridVertices) > 0:
             grid = Cluster.ByTopologies(gridVertices)
@@ -347,12 +346,17 @@ class Grid():
                 for v in vRange:
                     gridVertex = Face.VertexByParameters(face, u, v)
                     if clip and Topology.IsInstance(face, "Face"):
-                        gridVertex = gridVertex.Intersect(face, False)
-                    if Topology.IsInstance(gridVertex, "Vertex"):
-                        d = Dictionary.ByKeysValues(["u","v"],[u,v])
-                        if d:
-                            gridVertex.SetDictionary(d)
-                        gridVertices.append(gridVertex)
+                        if Vertex.IsInternal(gridVertex, face):
+                            d = Dictionary.ByKeysValues(["u","v"],[u,v])
+                            if d:
+                                gridVertex.SetDictionary(d)
+                            gridVertices.append(gridVertex)
+                    #     gridVertex = gridVertex.Intersect(face, False)
+                    # if Topology.IsInstance(gridVertex, "Vertex"):
+                    #     d = Dictionary.ByKeysValues(["u","v"],[u,v])
+                    #     if d:
+                    #         gridVertex.SetDictionary(d)
+                    #     gridVertices.append(gridVertex)
         grid = None
         if len(gridVertices) > 0:
             grid = Cluster.ByTopologies(gridVertices)

topologicpy/Plotly.py

@@ -592,6 +592,7 @@ class Plotly:
             mode = "markers+text"
         else:
             mode = "markers"
+
         vData2 = go.Scatter3d(x=x,
                             y=y,
                             z=z,
@@ -603,11 +604,13 @@ class Plotly:
                                         opacity=1,
                                         sizemode="diameter"),
                             mode=mode,
+                            customdata = labels,
                             legendgroup=legendGroup,
                             legendrank=legendRank,
                             text=labels,
                             hoverinfo='text',
-                            hovertext=labels
+                            hovertext=labels,
+                            hovertemplate=["Click "+label for label in labels]
                             )
         if borderWidth > 0 or borderWidthKey:
             vData1 = go.Scatter3d(x=x,
@@ -676,14 +679,13 @@ class Plotly:
             labels = []
             for j, elements_cluster in enumerate(elements_clusters):
                 d_color = color
-                labels.append("Edge_"+str(j+1).zfill(n))
                 d = dict_clusters[j][0] # All dicitonaries have same values in dictionaries, so take first one.
                 if d:
                     if not colorKey == None:
                         d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
                         d_color = Color.AnyToHex(d_color)
                     if not labelKey == None:
-                        label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
+                        labels.append(str(Dictionary.ValueAtKey(d, labelKey, "")))
                     if not widthKey == None:
                         e_width = Dictionary.ValueAtKey(d, key=widthKey)
                         if not e_width == None:
@@ -727,8 +729,10 @@ class Plotly:
                                     line=dict(color=d_color, width=width),
                                     legendgroup=legendGroup,
                                     legendrank=legendRank,
-                                    text=label,
-                                    hoverinfo='text')
+                                    text=labels,
+                                    customdata=labels,
+                                    hoverinfo='text',
+                                    hovertext=labels)
                 traces.append(trace)
         else:
             x = []
@@ -809,7 +813,8 @@ class Plotly:
                        faceLegendLabel="Topology Faces",
                        faceLegendRank=3,
                        faceLegendGroup=3, 
-                       intensityKey=None, intensities=[], colorScale="viridis", mantissa=6, tolerance=0.0001):
+                       intensityKey=None, intensities=[], colorScale="viridis",
+                       mantissa=6, tolerance=0.0001, silent=False):
         """
         Creates plotly face, edge, and vertex data.
 
@@ -1188,7 +1193,7 @@ class Plotly:
                 f_dictionaries = []
                 all_triangles = []
                 for tp_face in tp_faces:
-                    triangles = Face.Triangulate(tp_face, tolerance=tolerance)
+                    triangles = Face.Triangulate(tp_face, tolerance=tolerance, silent=silent)
                     if isinstance(triangles, list):
                         for tri in triangles:
                             if faceColorKey or faceOpacityKey or faceLabelKey or faceGroupKey: