topologicpy 0.7.15__py3-none-any.whl → 0.7.17__py3-none-any.whl

topologicpy/Cell.py

@@ -858,8 +858,7 @@ class Cell():
         
         baseWire = Wire.Circle(origin=circle_origin, radius=radius, sides=uSides, fromAngle=0, toAngle=360, close=True, direction=[0, 0, 1], placement="center", tolerance=tolerance)
         baseFace = Face.ByWire(baseWire, tolerance=tolerance)
-        cylinder = Cell.ByThickenedFace(face=baseFace, thickness=height, bothSides=False, reverse=True,
-                            tolerance=tolerance)
+        cylinder = Cell.ByThickenedFace(face=baseFace, thickness=height, bothSides=False, tolerance=tolerance)
         if vSides > 1:
             cutting_planes = []
             baseX = Vertex.X(origin, mantissa=mantissa) + xOffset
@@ -1032,14 +1031,14 @@ class Cell():
         cluster = Cluster.ByTopologies(pentagons)
         
         cluster2 = Topology.Rotate(cluster, origin=Vertex.Origin(), axis=[1, 0, 0], angle=180)
-        cluster2 = Topology.Rotate(cluster2, origin=Vertex.Origin(), axis=[0, 0, 1], angle=36)
-        vertices = Topology.Vertices(cluster2)
+        #cluster2 = Topology.Rotate(cluster2, origin=Vertex.Origin(), axis=[0, 0, 1], angle=36)
+        vertices = Topology.Vertices(cluster)
         zList = [Vertex.Z(v) for v in vertices]
         zList = list(set(zList))
         zList.sort()
-        zoffset1 = zList[-1] - zList[0]
-        zoffset2 = zList[1] - zList[0]
-        cluster2 = Topology.Translate(cluster2, 0, 0, -zoffset1-zoffset2)
+        zoffset = zList[1] - zList[0]
+        total_height = zList[-1] - zList[0]
+        cluster2 = Topology.Translate(cluster2, 0, 0, total_height+zoffset)
         pentagons += Topology.Faces(cluster2)
         dodecahedron = Cell.ByFaces(pentagons, tolerance=tolerance)
         centroid = Topology.Centroid(dodecahedron)
@@ -1052,6 +1051,12 @@ class Cell():
         elif placement == "lowerleft":
             dodecahedron = Topology.Translate(dodecahedron, radius, radius, radius)
         
+        geo = Topology.Geometry(dodecahedron)
+        vertices = [Vertex.ByCoordinates(coords) for coords in geo['vertices']]
+        vertices = Vertex.Fuse(vertices)
+        coords = [Vertex.Coordinates(v) for v in vertices]
+        dodecahedron = Topology.RemoveCoplanarFaces(Topology.SelfMerge(Topology.ByGeometry(vertices=coords, faces=geo['faces'])))
+        print(dodecahedron)
         dodecahedron = Topology.Orient(dodecahedron, origin=Vertex.Origin(), dirA=[0, 0, 1], dirB=direction, tolerance=tolerance)
         dodecahedron = Topology.Place(dodecahedron, originA=Vertex.Origin(), originB=origin)
         return dodecahedron
@@ -1393,7 +1398,7 @@ class Cell():
 
         icosahedron = Cell.ByFaces([f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,
                         f11,f12,f13,f14,f15,f16,f17,f18,f19,f20], tolerance=tolerance)
-        sf = 1.051*0.5 # To insribe it in a sphere of radius 0.5
+        sf = 1.051*0.5 # To inscribe it in a sphere of radius 0.5
         icosahedron = Topology.Scale(icosahedron, origin=Vertex.Origin(), x=sf, y=sf, z=sf)
         sf = radius/0.5
         icosahedron = Topology.Scale(icosahedron, origin=Vertex.Origin(), x=sf, y=sf, z=sf)
@@ -1823,7 +1828,7 @@ class Cell():
         ----------
         face : topologic_core.Face
             The input face.
-        angle : float , optioal
+        angle : float , optional
             The desired angle in degrees of the roof. The default is 45.
         epsilon : float , optional
             The desired epsilon (another form of tolerance for distance from plane). The default is 0.01. (This is set to a larger number as it was found to work better)
@@ -1865,7 +1870,7 @@ class Cell():
         Returns
         -------
         list
-            The classified list of input cells based on their encolsure within the input list of super cells.
+            The classified list of input cells based on their enclosure within the input list of super cells.
 
         """
 
@@ -1972,7 +1977,7 @@ class Cell():
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Sphere - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        c = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=vSides, fromAngle=-90, toAngle=90, close=False, direction=[0, 0, 1], placement="center")
+        c = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=vSides, fromAngle=0, toAngle=180, close=False, direction=[0, 0, 1], placement="center")
         c = Topology.Rotate(c, origin=Vertex.Origin(), axis=[1, 0, 0], angle=90)
         sphere = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0, 0, 1], angle=360, sides=uSides, tolerance=tolerance)
         if Topology.Type(sphere) == Topology.TypeID("CellComplex"):

topologicpy/CellComplex.py

@@ -1132,9 +1132,9 @@ class CellComplex():
                 vertices = Topology.Vertices(cell)
         else:
             vertices += Topology.Vertices(cell)
-        vertices = [v for v in vertices if (Vertex.IsInternal(v, cell) or not Vertex.Index(v, Topology.Vertices(cell)) == None)]
+        vertices = [v for v in vertices if (Vertex.IsInternal(v, cell) or not Vertex.Index(v, Topology.Vertices(cell), tolerance=tolerance) == None)]
         if len(vertices) < 1:
-            print("CellComplex.Voronoi - Error: The input vertices parame ter does not contain any vertices that are inside the input cell parameter. Returning None.")
+            print("CellComplex.Voronoi - Error: The input vertices parameter does not contain any vertices that are inside the input cell parameter. Returning None.")
             return None
         voronoi_points = np.array([Vertex.Coordinates(v) for v in vertices])
         cluster = fracture_with_voronoi(voronoi_points)

topologicpy/DGL.py

@@ -92,7 +92,7 @@ except:
         from dgl import save_graphs, load_graphs
         print("DGL - dgl library installed correctly.")
     except:
-        warnings.warn("DGL - Error: Could not import dgl. The installation of the correct version of the dgl library is not trivial and is highly dependent on your hardward and software configuration. Please consult the dgl installation instructions.")
+        warnings.warn("DGL - Error: Could not import dgl. The installation of the correct version of the dgl library is not trivial and is highly dependent on your hardware and software configuration. Please consult the dgl installation instructions.")
 
 try:
     from tqdm.auto import tqdm

topologicpy/Edge.py

@@ -84,13 +84,39 @@ class Edge():
             The created bisecting edge.
 
         """
-        import numpy as np
-
+        from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
+        import numpy as np
 
+
+        def process_edges(edge1, edge2, tolerance=0.0001):
+            start1 = Edge.StartVertex(edge1)
+            end1 = Edge.EndVertex(edge1)
+            start2 = Edge.StartVertex(edge2)
+            end2 = Edge.EndVertex(edge2)
+            
+            shared_vertex = None
+            
+            if Vertex.Distance(start1, start2) < tolerance:
+                shared_vertex = start1
+            elif Vertex.Distance(start1, end2) < tolerance:
+                shared_vertex = start1
+                edge2 = Edge.Reverse(edge2)
+            elif Vertex.Distance(end1, start2) < tolerance:
+                shared_vertex = start2
+                edge1 = Edge.Reverse(edge1)
+            elif Vertex.Distance(end1, end2) < tolerance:
+                shared_vertex = end1
+                edge1 = Edge.Reverse(edge1)
+                edge2 = Edge.Reverse(edge2)
+            
+            if shared_vertex is None:
+                return [None, None]
+            return edge1, edge2
+        
         if not Topology.IsInstance(edgeA, "Edge"):
             print("Edge.Bisect - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
             return None
@@ -104,21 +130,21 @@ class Edge():
             print("Edge.Bisect - Error: The input edgeB parameter is shorter than the input tolerance parameter. Returning None.")
             return None
         
-        wire = Topology.SelfMerge(Cluster.ByTopologies([edgeA, edgeB]), tolerance=tolerance)
-        if not Topology.IsInstance(wire, "Wire"):
+        
+        edge1, edge2 = process_edges(edgeA, edgeB, tolerance=tolerance)
+        if edge1 == None or edge2 == None:
             print("Edge.Bisect - Error: The input edgeA and edgeB parameters do not share a vertex and thus cannot be bisected. Returning None.")
             return None
-        edges = Topology.Edges(wire)
-        edgeA = edges[0]
-        edgeB = edges[1]
-
-        sv = Wire.Vertices(wire)[1]
-
-        dirA = Edge.Direction(edgeA)
-        dirB = Edge.Direction(edgeB)
-        bisecting_vector = Vector.Bisect(dirA, dirB)
+        sv = Edge.StartVertex(edge1)
+        dir1 = Edge.Direction(edge1)
+        dir2 = Edge.Direction(edge2)
+        bisecting_vector = Vector.Bisect(dir1, dir2)
         ev = Topology.TranslateByDirectionDistance(sv, bisecting_vector, length)
         bisecting_edge = Edge.ByVertices([sv, ev])
+        if placement == 0:
+            bisecting_edge = Topology.TranslateByDirectionDistance(bisecting_edge, Vector.Reverse(bisecting_vector), length*0.5)
+        elif placement == 2:
+            bisecting_edge = Topology.TranslateByDirectionDistance(bisecting_edge, Vector.Reverse(bisecting_vector), length)
         return bisecting_edge
 
     @staticmethod
@@ -130,7 +156,7 @@ class Edge():
         ----------
         face : topologic_core.Face
             The input face
-        origin : toopologic.Vertex , optional
+        origin : topologic_core.Vertex , optional
             The desired origin of the edge. If set to None, the centroid of the face is chosen as the origin of the edge. The default is None.
         length : float , optional
             The desired length of the edge. The default is 1.
@@ -178,7 +204,7 @@ class Edge():
             The input edge.
         offset : float , optional
             The desired offset. The default is 1.
-        tolerance : float , optiona
+        tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
         Returns
@@ -206,7 +232,7 @@ class Edge():
         ----------
         vertexA : topologic_core.Vertex
             The first input vertex. This is considered the start vertex.
-        vertexB : toopologic.Vertex
+        vertexB : topologic_core.Vertex
             The second input vertex. This is considered the end vertex.
         tolerance : float , optional
             The desired tolerance to decide if an Edge can be created. The default is 0.0001.
@@ -481,7 +507,7 @@ class Edge():
             if not silent:
                 print("Edge.ExtendToEdge - Error: The input edges are not coplanar. Returning the original edge.")
             return edgeA
-        if not Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+        if Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
             if not silent:
                 print("Edge.ExtendToEdge - Error: The input edges are parallel. Returning the original edge.")
             return edgeA
@@ -789,8 +815,8 @@ class Edge():
 
         x1, y1, z1 = Vertex.Coordinates(Edge.StartVertex(edgeA), mantissa=mantissa)
         x2, y2, z2 = Vertex.Coordinates(Edge.EndVertex(edgeA), mantissa=mantissa)
-        x3, y3, z3 = Vertex.Coordinates(Edge.StartVertex(edgeA), mantissa=mantissa)
-        x4, y4, z4 = Vertex.Coordinates(Edge.EndVertex(edgeA), mantissa=mantissa)
+        x3, y3, z3 = Vertex.Coordinates(Edge.StartVertex(edgeB), mantissa=mantissa)
+        x4, y4, z4 = Vertex.Coordinates(Edge.EndVertex(edgeB), mantissa=mantissa)
         line1 = ((x1, y1, z1), (x2, y2, z2))
         line2 = ((x3, y3, z3), (x4, y4, z4))
         return are_lines_parallel(line1, line2, tolerance=tolerance)
@@ -1239,7 +1265,7 @@ class Edge():
             if not silent:
                 print("Edge.TrimByEdge - Error: The input edges are not coplanar. Returning the original edge.")
             return edgeA
-        if not Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+        if Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
             if not silent:
                 print("Edge.TrimByEdge - Error: The input edges are parallel. Returning the original edge.")
             return edgeA

topologicpy/Face.py

@@ -258,11 +258,9 @@ class Face():
         return Face.ByEdges(edges, tolerance=tolerance)
 
     @staticmethod
-    def ByOffset(face, offset: float = 1.0, miter: bool = False,
-                 miterThreshold: float = None, offsetKey: str = None,
-                 miterThresholdKey: str = None, step: bool = True, tolerance: float = 0.0001):
+    def ByOffset(face, offset: float = 1.0, tolerance: float = 0.0001):
         """
-        Creates an offset face from the input face.
+        Creates an offset face from the input face. A positive offset value results in a smaller face to the inside of the input face.
 
         Parameters
         ----------
@@ -270,16 +268,6 @@ class Face():
             The input face.
         offset : float , optional
             The desired offset distance. The default is 1.0.
-        miter : bool , optional
-            if set to True, the corners will be mitered. The default is False.
-        miterThreshold : float , optional
-            The distance beyond which a miter should be added. The default is None which means the miter threshold is set to the offset distance multiplied by the square root of 2.
-        offsetKey : str , optional
-            If specified, the dictionary of the edges will be queried for this key to sepcify the desired offset. The default is None.
-        miterThresholdKey : str , optional
-            If specified, the dictionary of the vertices will be queried for this key to sepcify the desired miter threshold distance. The default is None.
-        step : bool , optional
-            If set to True, The transition between collinear edges with different offsets will be a step. Otherwise, it will be a continous edge. The default is True.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         
@@ -293,18 +281,18 @@ class Face():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.ByOffset - Warning: The input face parameter is not a valid toplogic face. Returning None.")
+            print("Face.ByOffset - Warning: The input face parameter is not a valid face. Returning None.")
             return None
         eb = Face.Wire(face)
         internal_boundaries = Face.InternalBoundaries(face)
-        offset_external_boundary = Wire.ByOffset(wire=eb, offset=offset, miter=miter, miterThreshold=miterThreshold, offsetKey=offsetKey, miterThresholdKey=miterThresholdKey, step=step)
+        offset_external_boundary = Wire.ByOffset(wire=eb, offset=offset, bisectors=False, tolerance=tolerance)
         offset_internal_boundaries = []
         for internal_boundary in internal_boundaries:
-            offset_internal_boundaries.append(Wire.ByOffset(wire=internal_boundary, offset=offset, miter=miter, miterThreshold=miterThreshold, offsetKey=offsetKey, miterThresholdKey=miterThresholdKey, step=step))
+            offset_internal_boundaries.append(Wire.ByOffset(wire=internal_boundary, offset=offset, bisectors=False, tolerance=tolerance))
         return Face.ByWires(offset_external_boundary, offset_internal_boundaries, tolerance=tolerance)
     
     @staticmethod
-    def ByShell(shell, origin= None, angTolerance: float = 0.1, tolerance: float = 0.0001):
+    def ByShell(shell, origin= None, angTolerance: float = 0.1, tolerance: float = 0.0001, silent=False):
         """
         Creates a face by merging the faces of the input shell.
 
@@ -351,13 +339,13 @@ class Face():
         face = None
         ext_boundary = Wire.RemoveCollinearEdges(Shell.ExternalBoundary(shell))
         if Topology.IsInstance(ext_boundary, "Wire"):
-            face = Face.ByWire(ext_boundary)
+            face = Face.ByWire(ext_boundary, silent=silent)
         elif Topology.IsInstance(ext_boundary, "Cluster"):
             wires = Topology.Wires(ext_boundary)
-            faces = [Face.ByWire(w) for w in wires]
+            faces = [Face.ByWire(w, silent=silent) for w in wires]
             areas = [Face.Area(f) for f in faces]
             wires = Helper.Sort(wires, areas, reverseFlags=[True])
-            face = Face.ByWires(wires[0], wires[1:])
+            face = Face.ByWires(wires[0], wires[1:], silent=silent)
 
         if Topology.IsInstance(face, "Face"):
             return face
@@ -420,6 +408,68 @@ class Face():
         else:
             return None
     
+    @staticmethod
+    def ByThickenedWire(wire, offsetA: float = 1.0, offsetB: float = 0.0, tolerance: float = 0.0001):
+        """
+        Creates a face by thickening the input wire. This method assumes the wire is manifold and planar.
+
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire to be thickened.
+        offsetA : float , optional
+            The desired offset to the exterior of the wire. The default is 1.0.
+        offsetB : float , optional
+            The desired offset to the interior of the wire. The default is 0.0.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The created cell.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Vector import Vector
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(wire, "Wire"):
+            print("Face.ByThickenedWire - Error: The input wire parameter is not a valid wire. Returning None.")
+            return None
+
+        three_vertices = Wire.Vertices(wire)[0:3]
+        temp_w = Wire.ByVertices(three_vertices, close=True)
+        flat_face = Face.ByWire(temp_w, tolerance=tolerance)
+        origin = Vertex.Origin()
+        normal = Face.Normal(flat_face)
+        flat_wire = Topology.Flatten(wire, origin=origin, direction=normal)
+        outside_wire = Wire.ByOffset(flat_wire, offset=abs(offsetA)*-1, bisectors = False, tolerance=tolerance)
+        inside_wire = Wire.ByOffset(flat_wire, offset=abs(offsetB), bisectors = False, tolerance=tolerance)
+        inside_wire = Wire.Reverse(inside_wire)
+        if not Wire.IsClosed(flat_wire):
+            sv = Topology.Vertices(flat_wire)[0]
+            ev = Topology.Vertices(flat_wire)[-1]
+            edges = Topology.Edges(flat_wire)
+            first_edge = Topology.SuperTopologies(sv, flat_wire, topologyType="edge")[0]
+            first_normal = Edge.Normal(first_edge)
+            last_edge = Topology.SuperTopologies(ev, flat_wire, topologyType="edge")[0]
+            last_normal = Edge.Normal(last_edge)
+            sv1 = Topology.TranslateByDirectionDistance(sv, first_normal, abs(offsetB))
+            sv2 = Topology.TranslateByDirectionDistance(sv, Vector.Reverse(first_normal), abs(offsetA))
+            ev1 = Topology.TranslateByDirectionDistance(ev, last_normal, abs(offsetB))
+            ev2 = Topology.TranslateByDirectionDistance(ev, Vector.Reverse(last_normal), abs(offsetA))
+            out_vertices = Topology.Vertices(outside_wire)[1:-1]
+            in_vertices = Topology.Vertices(inside_wire)[1:-1]
+            vertices = [sv2] + out_vertices + [ev2,ev1] + in_vertices + [sv1]
+            return_face = Face.ByWire(Wire.ByVertices(vertices))
+        else:
+            return_face = Face.ByWires(outside_wire, [inside_wire])
+        return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
+        return return_face
+    
     @staticmethod
     def ByVertices(vertices: list, tolerance: float = 0.0001):
         
@@ -839,7 +889,7 @@ class Face():
     def Einstein(origin= None, radius: float = 0.5, direction: list = [0, 0, 1],
                  placement: str = "center", tolerance: float = 0.0001):
         """
-        Creates an aperiodic monotile, also called an 'einstein' tile (meaning one tile in German, not the name of the famous physist). See https://arxiv.org/abs/2303.10798
+        Creates an aperiodic monotile, also called an 'einstein' tile (meaning one tile in German, not the name of the famous physicist). See https://arxiv.org/abs/2303.10798
 
         Parameters
         ----------
@@ -869,6 +919,64 @@ class Face():
             return None
         return Face.ByWire(wire, tolerance=tolerance)
     
+    @staticmethod
+    def Ellipse(origin= None, inputMode: int = 1, width: float = 2.0, length: float = 1.0, focalLength: float = 0.866025, eccentricity: float = 0.866025, majorAxisLength: float = 1.0, minorAxisLength: float = 0.5, sides: float = 32, fromAngle: float = 0.0, toAngle: float = 360.0, close: bool = True, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates an ellipse and returns all its geometry and parameters.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the ellipse. The default is None which results in the ellipse being placed at (0, 0, 0).
+        inputMode : int , optional
+            The method by which the ellipse is defined. The default is 1.
+            Based on the inputMode value, only the following inputs will be considered. The options are:
+            1. Width and Length (considered inputs: width, length)
+            2. Focal Length and Eccentricity (considered inputs: focalLength, eccentricity)
+            3. Focal Length and Minor Axis Length (considered inputs: focalLength, minorAxisLength)
+            4. Major Axis Length and Minor Axis Length (considered input: majorAxisLength, minorAxisLength)
+        width : float , optional
+            The width of the ellipse. The default is 2.0. This is considered if the inputMode is 1.
+        length : float , optional
+            The length of the ellipse. The default is 1.0. This is considered if the inputMode is 1.
+        focalLength : float , optional
+            The focal length of the ellipse. The default is 0.866025. This is considered if the inputMode is 2 or 3.
+        eccentricity : float , optional
+            The eccentricity of the ellipse. The default is 0.866025. This is considered if the inputMode is 2.
+        majorAxisLength : float , optional
+            The length of the major axis of the ellipse. The default is 1.0. This is considered if the inputMode is 4.
+        minorAxisLength : float , optional
+            The length of the minor axis of the ellipse. The default is 0.5. This is considered if the inputMode is 3 or 4.
+        sides : int , optional
+            The number of sides of the ellipse. The default is 32.
+        fromAngle : float , optional
+            The angle in degrees from which to start creating the arc of the ellipse. The default is 0.
+        toAngle : float , optional
+            The angle in degrees at which to end creating the arc of the ellipse. The default is 360.
+        close : bool , optional
+            If set to True, arcs will be closed by connecting the last vertex to the first vertex. Otherwise, they will be left open.
+        direction : list , optional
+            The vector representing the up direction of the ellipse. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the ellipse. 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.Face
+            The created ellipse
+
+        """
+        from topologicpy.Wire import Wire
+        w = Wire.Ellipse(origin=origin, inputMode=inputMode, width=width, length=length,
+                         focalLength=focalLength, eccentricity=eccentricity,
+                         majorAxisLength=majorAxisLength, minorAxisLength=minorAxisLength,
+                         sides=sides, fromAngle=fromAngle, toAngle=toAngle,
+                         close=close, direction=direction,
+                         placement=placement, tolerance=tolerance)
+        return Face.ByWire(w)
+    
     @staticmethod
     def ExteriorAngles(face, includeInternalBoundaries=False, mantissa: int = 6) -> list:
         """
@@ -1256,10 +1364,10 @@ class Face():
                 return None
 
         if not Topology.IsInstance(faceA, "Face"):
-            print("Face.IsInide - Error: The input faceA parameter is not a valid topologic face. Returning None.")
+            print("Face.IsInside - Error: The input faceA parameter is not a valid topologic face. Returning None.")
             return None
         if not Topology.IsInstance(faceB, "Face"):
-            print("Face.IsInide - Error: The input faceB parameter is not a valid topologic face. Returning None.")
+            print("Face.IsInside - Error: The input faceB parameter is not a valid topologic face. Returning None.")
             return None
 
         def normalize_plane_coefficients(plane):
@@ -1924,7 +2032,7 @@ class Face():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
-            print("Face.Skeleton - Error: The input face is not a valid topologic face. Retruning None.")
+            print("Face.Skeleton - Error: The input face is not a valid topologic face. Returning None.")
             return None
         return Wire.Skeleton(face, tolerance=tolerance)