topologicpy 0.8.25__py3-none-any.whl → 0.8.28__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 = [],
@@ -4487,7 +4685,7 @@ class Graph:
                 weightClosenessCentrality: float = 0.0,
                 weightDegreeCentrality: float = 0.0,
                 weightDiameter: float = 0.0,
-                weightEigenCentrality: float = 0.0,
+                weightEigenVectorCentrality: float = 0.0,
                 weightGlobalClusteringCoefficient: float = 0.0,
                 weightPageRank: float = 0.0,
                 weightStructure: float = 0.0,
@@ -4521,8 +4719,8 @@ class Graph:
             The desired weight for degree centrality similarity (graph-level and node-level). Default is 0.0.
         weightDiameter : float , optional
             The desired weight for diameter similarity (graph-level and node-level). Default is 0.0.
-        weightEigenCentrality : float , optional
-            The desired weight for eigen centrality similarity (graph-level and node-level). Default is 0.0.
+        weightEigenVectorCentrality : float , optional
+            The desired weight for eigenvector centrality similarity (graph-level and node-level). Default is 0.0.
         weightGeometry : float , optional
             The desired weight for geometric similarity (vertex positions). Default is 0.0.
         weightGlobalClusteringCoefficient : float , optional
@@ -4559,7 +4757,7 @@ class Graph:
             "betwenness_centrality"
             "closeness_centrality"
             "degree_centrality"
-            "eigen_centrality"
+            "eigenvector_centrality"
             "geometry"
             "global_clustering_coefficient"
             "jaccard"
@@ -4722,9 +4920,9 @@ class Graph:
             diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
             return round((1 - diff), mantissa)
         
-        def eigen_centrality_similarity(graphA, graphB, mantissa=6):
-            v1 = safe_mean(Graph.EigenCentrality(graphA))
-            v2 = safe_mean(Graph.EigenCentrality(graphB))
+        def eigenvector_centrality_similarity(graphA, graphB, mantissa=6):
+            v1 = safe_mean(Graph.EigenVectorCentrality(graphA))
+            v2 = safe_mean(Graph.EigenVectorCentrality(graphB))
             if v1 == 0 and v2 == 0:
                 return 1
             diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
@@ -4807,7 +5005,7 @@ class Graph:
                             weightClosenessCentrality,
                             weightDegreeCentrality,
                             weightDiameter,
-                            weightEigenCentrality,
+                            weightEigenVectorCentrality,
                             weightGlobalClusteringCoefficient,
                             weightPageRank,
                             weightStructure,
@@ -4819,7 +5017,7 @@ class Graph:
         closeness_centrality_score = closeness_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightClosenessCentrality else 0
         degree_centrality_score = degree_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightDegreeCentrality else 0
         diameter_score = diameter_similarity(graphA, graphB, mantissa=mantissa) if weightDiameter else 0
-        eigen_centrality_score = eigen_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightEigenCentrality else 0
+        eigenvector_centrality_score = eigenvector_centrality_similarity(graphA, graphB, mantissa=mantissa) if weightEigenVectorCentrality else 0
         global_clustering_coefficient_score = global_clustering_coefficient_similarity(graphA, graphB, mantissa=mantissa) if weightGlobalClusteringCoefficient else 0
         geometry_score = geometry_similarity(graphA, graphB, mantissa=mantissa) if weightGeometry else 0
         jaccard_score = weighted_jaccard_similarity(graphA, graphB, vertexIDKey=vertexIDKey, edgeWeightKey=edgeWeightKey, mantissa=mantissa) if weightJaccard else 0
@@ -4834,7 +5032,7 @@ class Graph:
             closeness_centrality_score * weightClosenessCentrality +
             degree_centrality_score * weightDegreeCentrality +
             diameter_score * weightDiameter +
-            eigen_centrality_score * weightEigenCentrality +
+            eigenvector_centrality_score * weightEigenVectorCentrality +
             geometry_score * weightGeometry +
             global_clustering_coefficient_score * weightGlobalClusteringCoefficient +
             jaccard_score * weightJaccard +
@@ -4854,7 +5052,7 @@ class Graph:
                  "betwenness_centrality": round(betweenness_centrality_score, mantissa),
                  "closeness_centrality": round(closeness_centrality_score, mantissa),
                  "degree_centrality": round(degree_centrality_score, mantissa),
-                 "eigen_centrality": round(eigen_centrality_score, mantissa),
+                 "eigenvector_centrality": round(eigenvector_centrality_score, mantissa),
                  "geometry": round(geometry_score, mantissa),
                  "global_clustering_coefficient": round(global_clustering_coefficient_score, mantissa),
                  "jaccard": round(jaccard_score, mantissa),
@@ -5239,9 +5437,9 @@ class Graph:
             if "len" in weightKey.lower() or "dis" in weightKey.lower():
                 weightKey = "length"
         nx_graph = Graph.NetworkXGraph(graph)
-        elements = Graph.Vertices(graph)
-        elements_dict = nx.closeness_centrality(nx_graph, distance=weightKey, wf_improved=nxCompatible)
-        values = [round(v, mantissa) for v in list(elements_dict.values())]
+        vertices = Graph.Vertices(graph)
+        vertices_dict = nx.closeness_centrality(nx_graph, distance=weightKey, wf_improved=nxCompatible)
+        values = [round(v, mantissa) for v in list(vertices_dict.values())]
         if normalize == True:
             if mantissa > 0: # We cannot round numbers from 0 to 1 with a mantissa = 0.
                 values = [round(v, mantissa) for v in Helper.Normalize(values)]
@@ -5254,10 +5452,10 @@ class Graph:
             max_value = max(values)
 
         for i, value in enumerate(values):
-            d = Topology.Dictionary(elements[i])
+            d = Topology.Dictionary(vertices[i])
             color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
             d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
-            elements[i] = Topology.SetDictionary(elements[i], d)
+            vertices[i] = Topology.SetDictionary(vertices[i], d)
 
         return values
 
@@ -6051,7 +6249,7 @@ class Graph:
         return list(dict.fromkeys(edges)) # remove duplicates
     
     @staticmethod
-    def EigenCentrality(graph, normalize: bool = False, key: str = "eigen_centrality", colorKey: str = "ec_color", colorScale: str = "viridis", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
+    def EigenVectorCentrality(graph, normalize: bool = False, key: str = "eigen_vector_centrality", colorKey: str = "evc_color", colorScale: str = "viridis", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
         Returns the eigenvector centrality of the input graph. The order of the returned list is the same as the order of vertices.
 
@@ -6064,9 +6262,9 @@ class Graph:
         normalize : bool, optional
             If set to True, the centrality values are normalized to be in the range 0 to 1. The default is False.
         key : str, optional
-            The desired dictionary key under which to store the eigenvector centrality score. The default is "eigen_centrality".
+            The desired dictionary key under which to store the eigenvector centrality score. The default is "eigen_vector_centrality".
         colorKey : str, optional
-            The desired dictionary key under which to store the eigenvector centrality color. The default is "ec_color".
+            The desired dictionary key under which to store the eigenvector centrality color. The default is "evc_color".
         colorScale : str, optional
             The desired type of Plotly color scale to use (e.g., "viridis", "plasma"). Default is "viridis".
             For a full list of names, see https://plotly.com/python/builtin-colorscales/.
@@ -6092,7 +6290,7 @@ class Graph:
 
         if not Topology.IsInstance(graph, "graph"):
             if not silent:
-                print("Graph.EigenCentrality - Error: The input graph is not a valie Topologic Graph. Returning None.")
+                print("Graph.EigenVectorCentrality - Error: The input graph is not a valie Topologic Graph. Returning None.")
             return None
         adjacency_matrix = Graph.AdjacencyMatrix(graph)
         vertices = Graph.Vertices(graph)
@@ -10474,9 +10672,9 @@ class Graph:
         return outgoing_vertices
     
     @staticmethod
-    def PageRank(graph, alpha: float = 0.85, maxIterations: int = 100, normalize: bool = True, directed: bool = False, key: str = "page_rank", mantissa: int = 6, tolerance: float = 0.0001):
+    def PageRank(graph, alpha: float = 0.85, maxIterations: int = 100, normalize: bool = True, directed: bool = False, key: str = "page_rank", colorKey="pr_color", colorScale="viridis", mantissa: int = 6, tolerance: float = 0.0001):
         """
-        Calculates PageRank scores for nodes in a directed graph. see https://en.wikipedia.org/wiki/PageRank.
+        Calculates PageRank scores for vertices in a directed graph. see https://en.wikipedia.org/wiki/PageRank.
 
         Parameters
         ----------
@@ -10492,6 +10690,11 @@ class Graph:
             If set to True, the graph is considered as a directed graph. Otherwise, it will be considered as an undirected graph. The default is False.
         key : str , optional
             The dictionary key under which to store the page_rank score. The default is "page_rank"
+        colorKey : str , optional
+            The desired dictionary key under which to store the pagerank color. The default is "pr_color".
+        colorScale : str , optional
+            The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+            In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
         mantissa : int , optional
             The desired length of the mantissa.
         tolerance : float , optional
@@ -10506,6 +10709,7 @@ class Graph:
         from topologicpy.Helper import Helper
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
+        from topologicpy.Color import Color
 
         vertices = Graph.Vertices(graph)
         num_vertices = len(vertices)
@@ -10513,7 +10717,7 @@ class Graph:
             print("Graph.PageRank - Error: The input graph parameter has no vertices. Returning None")
             return None
         initial_score = 1.0 / num_vertices
-        scores = [initial_score for vertex in vertices]
+        values = [initial_score for vertex in vertices]
         for _ in range(maxIterations):
             new_scores = [0 for vertex in vertices]
             for i, vertex in enumerate(vertices):
@@ -10522,23 +10726,36 @@ class Graph:
                     if len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed)) > 0:
                         vi = Vertex.Index(incoming_vertex, vertices, tolerance=tolerance)
                         if not vi == None:
-                            incoming_score += scores[vi] / len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed))
+                            incoming_score += values[vi] / len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed))
                 new_scores[i] = alpha * incoming_score + (1 - alpha) / num_vertices
 
             # Check for convergence
-            if all(abs(new_scores[i] - scores[i]) <= tolerance for i in range(len(vertices))):
+            if all(abs(new_scores[i] - values[i]) <= tolerance for i in range(len(vertices))):
                 break
 
-            scores = new_scores
+            values = new_scores
         if normalize == True:
-            scores = Helper.Normalize(scores, mantissa=mantissa)
+            if mantissa > 0: # We cannot round numbers from 0 to 1 with a mantissa = 0.
+                values = [round(v, mantissa) for v in Helper.Normalize(values)]
+            else:
+                values = Helper.Normalize(values)
+            min_value = 0
+            max_value = 1
         else:
-            scores = [round(x, mantissa) for x in scores]
+            min_value = min(values)
+            max_value = max(values)
+
+        for i, value in enumerate(values):
+            d = Topology.Dictionary(vertices[i])
+            color = Color.AnyToHex(Color.ByValueInRange(value, minValue=min_value, maxValue=max_value, colorScale=colorScale))
+            d = Dictionary.SetValuesAtKeys(d, [key, colorKey], [value, color])
+            vertices[i] = Topology.SetDictionary(vertices[i], d)
+        
         for i, v in enumerate(vertices):
             d = Topology.Dictionary(v)
-            d = Dictionary.SetValueAtKey(d, key, scores[i])
+            d = Dictionary.SetValueAtKey(d, key, values[i])
             v = Topology.SetDictionary(v, d)
-        return scores
+        return values
 
     @staticmethod
     def Partition(graph, method: str = "Betweenness", n: int = 2, m: int = 10, key: str ="partition",

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

@@ -809,7 +809,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 +1189,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:

topologicpy/Shell.py

@@ -1846,6 +1846,42 @@ class Shell():
             final_result = Shell.ByFaces(final_faces, tolerance=tolerance)
         return final_result
 
+    @staticmethod
+    def Square(origin= None, size: float = 1.0,
+                  uSides: int = 2, vSides: int = 2, direction: list = [0, 0, 1],
+                  placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates a square.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the square. The default is None which results in the square being placed at (0, 0, 0).
+        size : float , optional
+            The size of the square. The default is 1.0.
+        length : float , optional
+            The length of the square. The default is 1.0.
+        uSides : int , optional
+            The number of sides along the width. The default is 2.
+        vSides : int , optional
+            The number of sides along the length. The default is 2.
+        direction : list , optional
+            The vector representing the up direction of the square. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the square. This can be "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Shell
+            The created shell square.
+
+        """
+        return Shell.Rectangle(origin=origin, width=size, length=size,
+                  uSides=uSides, vSides=vSides, direction=direction,
+                  placement=placement, tolerance=tolerance)
+    
     @staticmethod
     def Vertices(shell) -> list:
         """