mightyscape-1.1-deprecated/extensions/fablabchemnitz/paperfold.py

#!/usr/bin/env python3
import openmesh as om
import math
import inkex
import tempfile
import os
import random
import numpy as np
import openmesh as om
import networkx as nx
from lxml import etree
from inkex import Transform, TextElement, Tspan, Color, Circle

"""
Extension for InkScape 1.0

Paperfold is another flattener for triangle mesh files, heavily based on paperfoldmodels by Felix Scholz aka felixfeliz.

Author: Mario Voigt / FabLab Chemnitz
Mail: mario.voigt@stadtfabrikanten.org
Date: 13.09.2020
Last patch: 10.05.2021
License: GNU GPL v3

To run this you need to install OpenMesh with python pip. 

The algorithm of paperfoldmodels consists of three steps:
  - Find a minimum spanning tree of the dual graph of the mesh.
  - Unfold the dual graph.
  - Remove self-intersections by adding additional cuts along edges.
  
Reference: The code is mostly based on the algorithm presented in a by Straub and Prautzsch (https://geom.ivd.kit.edu/downloads/proj-paper-models_cut_out_sheets.pdf).

Module licenses
- paperfoldmodels (https://github.com/felixfeliz/paperfoldmodels) - MIT License

possible import file types -> https://www.graphics.rwth-aachen.de/media/openmesh_static/Documentations/OpenMesh-8.0-Documentation/a04096.html

todo:
- option to render all triangles in a detached way (overlapping lines/independent) + merge coplanar adjacent triangles to polygons
- write tab and slot generator (like joinery/polyhedra extension)
- fstl preview
- fix line: dualGraph.add_edge(face1.idx(), face2.idx(), idx=edge.idx(), weight=edgeweight) # #might fail without throwing any error (silent aborts) ...
"""

class Unfold(inkex.EffectExtension):

    angleRangeCalculated = False #set to true after first calculation iteration (needed globally)
    minAngle = 0
    minAngle = 0
    angleRange = 0

    # Compute the third point of a triangle when two points and all edge lengths are given
    def getThirdPoint(self, v0, v1, l01, l12, l20):
        v2rotx = (l01 ** 2 + l20 ** 2 - l12 ** 2) / (2 * l01)
        v2roty0 = np.sqrt((l01 + l20 + l12) * (l01 + l20 - l12) * (l01 - l20 + l12) * (-l01 + l20 + l12)) / (2 * l01)
    
        v2roty1 = - v2roty0
    
        theta = np.arctan2(v1[1] - v0[1], v1[0] - v0[0])
    
        v2trans0 = np.array(
            [v2rotx * np.cos(theta) - v2roty0 * np.sin(theta), v2rotx * np.sin(theta) + v2roty0 * np.cos(theta), 0])
        v2trans1 = np.array(
            [v2rotx * np.cos(theta) - v2roty1 * np.sin(theta), v2rotx * np.sin(theta) + v2roty1 * np.cos(theta), 0])
        return [v2trans0 + v0, v2trans1 + v0]
    
    
    # Check if two lines intersect
    def lineIntersection(self, v1, v2, v3, v4, epsilon):
        d = (v4[1] - v3[1]) * (v2[0] - v1[0]) - (v4[0] - v3[0]) * (v2[1] - v1[1])
        u = (v4[0] - v3[0]) * (v1[1] - v3[1]) - (v4[1] - v3[1]) * (v1[0] - v3[0])
        v = (v2[0] - v1[0]) * (v1[1] - v3[1]) - (v2[1] - v1[1]) * (v1[0] - v3[0])
        if d < 0:
            u, v, d = -u, -v, -d
        return ((0 + epsilon) <= u <= (d - epsilon)) and ((0 + epsilon) <= v <= (d - epsilon))
    
    # Check if a point lies inside a triangle
    def pointInTriangle(self, A, B, C, P, epsilon):
        v0 = [C[0] - A[0], C[1] - A[1]]
        v1 = [B[0] - A[0], B[1] - A[1]]
        v2 = [P[0] - A[0], P[1] - A[1]]
        cross = lambda u, v: u[0] * v[1] - u[1] * v[0]
        u = cross(v2, v0)
        v = cross(v1, v2)
        d = cross(v1, v0)
        if d < 0:
            u, v, d = -u, -v, -d
        return u >= (0 + epsilon) and v >= (0 + epsilon) and (u + v) <= (d - epsilon)
    
    
    # Check if two triangles intersect
    def triangleIntersection(self, t1, t2, epsilon):
        if self.lineIntersection(t1[0], t1[1], t2[0], t2[1], epsilon): return True
        if self.lineIntersection(t1[0], t1[1], t2[0], t2[2], epsilon): return True
        if self.lineIntersection(t1[0], t1[1], t2[1], t2[2], epsilon): return True
        if self.lineIntersection(t1[0], t1[2], t2[0], t2[1], epsilon): return True
        if self.lineIntersection(t1[0], t1[2], t2[0], t2[2], epsilon): return True
        if self.lineIntersection(t1[0], t1[2], t2[1], t2[2], epsilon): return True
        if self.lineIntersection(t1[1], t1[2], t2[0], t2[1], epsilon): return True
        if self.lineIntersection(t1[1], t1[2], t2[0], t2[2], epsilon): return True
        if self.lineIntersection(t1[1], t1[2], t2[1], t2[2], epsilon): return True
        inTri = True
        inTri = inTri and self.pointInTriangle(t1[0], t1[1], t1[2], t2[0], epsilon)
        inTri = inTri and self.pointInTriangle(t1[0], t1[1], t1[2], t2[1], epsilon)
        inTri = inTri and self.pointInTriangle(t1[0], t1[1], t1[2], t2[2], epsilon)
        if inTri == True: return True
        inTri = True
        inTri = inTri and self.pointInTriangle(t2[0], t2[1], t2[2], t1[0], epsilon)
        inTri = inTri and self.pointInTriangle(t2[0], t2[1], t2[2], t1[1], epsilon)
        inTri = inTri and self.pointInTriangle(t2[0], t2[1], t2[2], t1[2], epsilon)
        if inTri == True: return True
        return False
    
    
    # Functions for visualisation and output
    def addVisualisationData(self, mesh, unfoldedMesh, originalHalfedges, unfoldedHalfedges, glueNumber, dihedralAngles):
        for i in range(3):
            dihedralAngles[unfoldedMesh.edge_handle(unfoldedHalfedges[i]).idx()] = round(math.degrees(mesh.calc_dihedral_angle(originalHalfedges[i])), self.options.roundingDigits)
            # Information, which edges belong together
            glueNumber[unfoldedMesh.edge_handle(unfoldedHalfedges[i]).idx()] = mesh.edge_handle(originalHalfedges[i]).idx()
    
     # Function that unwinds a spanning tree
    def unfoldSpanningTree(self, mesh, spanningTree): 
        try:
            unfoldedMesh = om.TriMesh()  # the unfolded mesh
        
            numFaces = mesh.n_faces()
            sizeTree = spanningTree.number_of_edges()
            numUnfoldedEdges = 3 * numFaces - sizeTree
        
            isFoldingEdge = np.zeros(numUnfoldedEdges, dtype=bool)  # Indicates whether an edge is folded or cut
            glueNumber = np.empty(numUnfoldedEdges, dtype=int)  # Saves with which edge is glued together
            dihedralAngles = np.empty(numUnfoldedEdges, dtype=float)  # Valley folding or mountain folding
            connections = np.empty(numFaces, dtype=int)  # Saves which original triangle belongs to the unrolled one
        
            # Select the first triangle as desired
            startingNode = list(spanningTree.nodes())[0]
            startingTriangle = mesh.face_handle(startingNode)
        
            # We unwind the first triangle
        
            # All half edges of the first triangle
            firstHalfEdge = mesh.halfedge_handle(startingTriangle)
            secondHalfEdge = mesh.next_halfedge_handle(firstHalfEdge)
            thirdHalfEdge = mesh.next_halfedge_handle(secondHalfEdge)
            originalHalfEdges = [firstHalfEdge, secondHalfEdge, thirdHalfEdge]
        
            # Calculate the lengths of the edges, this will determine the shape of the triangle (congruence)
            edgelengths = [mesh.calc_edge_length(firstHalfEdge), mesh.calc_edge_length(secondHalfEdge),
                           mesh.calc_edge_length(thirdHalfEdge)]
        
            # The first two points
            firstUnfoldedPoint = np.array([0, 0, 0])
            secondUnfoldedPoint = np.array([edgelengths[0], 0, 0])
        
            # We calculate the third point of the triangle from the first two. There are two possibilities
            [thirdUnfolded0, thirdUnfolded1] = self.getThirdPoint(firstUnfoldedPoint, secondUnfoldedPoint, edgelengths[0],
                                                             edgelengths[1],
                                                             edgelengths[2])
            if thirdUnfolded0[1] > 0:
                thirdUnfoldedPoint = thirdUnfolded0
            else:
                thirdUnfoldePoint = thirdUnfolded1
        
            # Add the new corners to the unwound net
            firstUnfoldedVertex = unfoldedMesh.add_vertex(secondUnfoldedPoint)
            secondUnfoldedVertex = unfoldedMesh.add_vertex(thirdUnfoldedPoint)
            thirdUnfoldedVertex = unfoldedMesh.add_vertex(firstUnfoldedPoint)
        
            #firstUnfoldedVertex = unfoldedMesh.add_vertex(firstUnfoldedPoint)
            #secondUnfoldedVertex = unfoldedMesh.add_vertex(secondUnfoldedPoint)
            #thirdUnfoldedVertex = unfoldedMesh.add_vertex(thirdUnfoldedPoint)
        
            # Create the page
            unfoldedFace = unfoldedMesh.add_face(firstUnfoldedVertex, secondUnfoldedVertex, thirdUnfoldedVertex)
        
            # Memory properties of the surface and edges
            # The half edges in unrolled mesh
            firstUnfoldedHalfEdge = unfoldedMesh.opposite_halfedge_handle(unfoldedMesh.halfedge_handle(firstUnfoldedVertex))
            secondUnfoldedHalfEdge = unfoldedMesh.next_halfedge_handle(firstUnfoldedHalfEdge)
            thirdUnfoldedHalfEdge = unfoldedMesh.next_halfedge_handle(secondUnfoldedHalfEdge)
        
            unfoldedHalfEdges = [firstUnfoldedHalfEdge, secondUnfoldedHalfEdge, thirdUnfoldedHalfEdge]
        
            # Associated triangle in 3D mesh
            connections[unfoldedFace.idx()] = startingTriangle.idx()
            # Folding direction and adhesive number
            self.addVisualisationData(mesh, unfoldedMesh, originalHalfEdges, unfoldedHalfEdges, glueNumber, dihedralAngles)
        
            if self.angleRangeCalculated is False:
                self.minAngle = min(dihedralAngles)
                self.maxAngle = max(dihedralAngles)
                #sometimes weird large value are returned, like -34345645435464565453356788761029782
                if self.minAngle < -180.0:
                    self.minAngle = -180.0
                if self.maxAngle > 180.0:
                    self.maxAngle = 180.0
                self.angleRange = self.maxAngle - self.minAngle
                #self.msg(minAngle)
                #self.msg(maxAngle)
                #self.msg(angleRange)
                self.angleRangeCalculated = True
        
            halfEdgeConnections = {firstHalfEdge.idx(): firstUnfoldedHalfEdge.idx(),
                                   secondHalfEdge.idx(): secondUnfoldedHalfEdge.idx(),
                                   thirdHalfEdge.idx(): thirdUnfoldedHalfEdge.idx()}
        
            # We walk through the tree
            for dualEdge in nx.dfs_edges(spanningTree, source=startingNode):
                foldingEdge = mesh.edge_handle(spanningTree[dualEdge[0]][dualEdge[1]]['idx'])
                # Find the corresponding half edge in the output triangle
                foldingHalfEdge = mesh.halfedge_handle(foldingEdge, 0)
                if not (mesh.face_handle(foldingHalfEdge).idx() == dualEdge[0]):
                    foldingHalfEdge = mesh.halfedge_handle(foldingEdge, 1)
        
                # Find the corresponding unwound half edge
                unfoldedLastHalfEdge = unfoldedMesh.halfedge_handle(halfEdgeConnections[foldingHalfEdge.idx()])
        
                # Find the point in the unrolled triangle that is not on the folding edge
                oppositeUnfoldedVertex = unfoldedMesh.to_vertex_handle(unfoldedMesh.next_halfedge_handle(unfoldedLastHalfEdge))
        
                # We turn the half edges over to lie in the new triangle
                foldingHalfEdge = mesh.opposite_halfedge_handle(foldingHalfEdge)
                unfoldedLastHalfEdge = unfoldedMesh.opposite_halfedge_handle(unfoldedLastHalfEdge)
        
                # The two corners of the folding edge
                unfoldedFromVertex = unfoldedMesh.from_vertex_handle(unfoldedLastHalfEdge)
                unfoldedToVertex = unfoldedMesh.to_vertex_handle(unfoldedLastHalfEdge)
        
                # Calculate the edge lengths in the new triangle
                secondHalfEdgeInFace = mesh.next_halfedge_handle(foldingHalfEdge)
                thirdHalfEdgeInFace = mesh.next_halfedge_handle(secondHalfEdgeInFace)
        
                originalHalfEdges = [foldingHalfEdge, secondHalfEdgeInFace, thirdHalfEdgeInFace]
        
                edgelengths = [mesh.calc_edge_length(foldingHalfEdge), mesh.calc_edge_length(secondHalfEdgeInFace),
                               mesh.calc_edge_length(thirdHalfEdgeInFace)]
        
                # We calculate the two possibilities for the third point in the triangle
                [newUnfoldedVertex0, newUnfoldedVertex1] = self.getThirdPoint(unfoldedMesh.point(unfoldedFromVertex),
                                                                         unfoldedMesh.point(unfoldedToVertex), edgelengths[0],
                                                                         edgelengths[1], edgelengths[2])
        
        
                newUnfoldedVertex = unfoldedMesh.add_vertex(newUnfoldedVertex0)
        
                # Make the face
                newface = unfoldedMesh.add_face(unfoldedFromVertex, unfoldedToVertex, newUnfoldedVertex)
        
                secondUnfoldedHalfEdge = unfoldedMesh.next_halfedge_handle(unfoldedLastHalfEdge)
                thirdUnfoldedHalfEdge = unfoldedMesh.next_halfedge_handle(secondUnfoldedHalfEdge)
                unfoldedHalfEdges = [unfoldedLastHalfEdge, secondUnfoldedHalfEdge, thirdUnfoldedHalfEdge]
        
                # Saving the information about edges and page
                # Dotted one's in the output
                unfoldedLastEdge = unfoldedMesh.edge_handle(unfoldedLastHalfEdge)
                isFoldingEdge[unfoldedLastEdge.idx()] = True
        
                # Gluing number and folding direction
                self.addVisualisationData(mesh, unfoldedMesh, originalHalfEdges, unfoldedHalfEdges, glueNumber, dihedralAngles)
        
                # Related page
                connections[newface.idx()] = dualEdge[1]
        
                # Identify the half edges
                for i in range(3):
                    halfEdgeConnections[originalHalfEdges[i].idx()] = unfoldedHalfEdges[i].idx()
        
            return [unfoldedMesh, isFoldingEdge, connections, glueNumber, dihedralAngles]
        except Exception as e:
            inkex.utils.debug("Error: model could not be unfolded. Check for:")
            inkex.utils.debug(" - watertight model / intact hull")
            inkex.utils.debug(" - duplicated edges or faces")
            inkex.utils.debug(" - detached faces or holes")
            inkex.utils.debug(" - missing units")
            inkex.utils.debug(" - missing coordinate system")
            inkex.utils.debug(" - multiple bodies in one file")
            inkex.utils.debug("error was: " + str(e))
            exit(1)
 
    
    def unfold(self, mesh):
        # Calculate the number of surfaces, edges and corners, as well as the length of the longest shortest edge
        numEdges = mesh.n_edges()
        numVertices = mesh.n_vertices()
        numFaces = mesh.n_faces()
    
        if numFaces > self.options.maxNumFaces:
            inkex.utils.debug("Aborted. Target STL file has " + str(numFaces) + " faces, but only " + str( self.options.maxNumFaces) + " are allowed.")
            exit(1)
    
        if self.options.printStats is True:
            inkex.utils.debug("Input STL mesh stats:")
            inkex.utils.debug("* Number of edges: " + str(numEdges))
            inkex.utils.debug("* Number of vertices: " + str(numVertices))
            inkex.utils.debug("* Number of faces: " + str(numFaces))
            inkex.utils.debug("-----------------------------------------------------------")
    
        # Generate the dual graph of the mesh and calculate the weights
        dualGraph = nx.Graph()
    
        # For the weights: calculate the longest and shortest edge of the triangle
        minLength = 1000
        maxLength = 0
        for edge in mesh.edges():
            edgelength = mesh.calc_edge_length(edge)
            if edgelength < minLength:
                minLength = edgelength
            if edgelength > maxLength:
                maxLength = edgelength
    
        # All edges in the net
        for edge in mesh.edges():
            #inkex.utils.debug("edge.idx = " + str(edge.idx()))
            
            # The two sides adjacent to the edge
            face1 = mesh.face_handle(mesh.halfedge_handle(edge, 0))
            face2 = mesh.face_handle(mesh.halfedge_handle(edge, 1))
    
            # The weight
            edgeweight = 1.0 - (mesh.calc_edge_length(edge) - minLength) / (maxLength - minLength)
            #inkex.utils.debug("edgeweight = " + str(edgeweight))
    
            # Calculate the centres of the pages (only necessary for visualisation)
            center1 = (0, 0)
            for vertex in mesh.fv(face1):
                center1 = center1 + 0.3333333333333333 * np.array([mesh.point(vertex)[0], mesh.point(vertex)[2]])
            center2 = (0, 0)
            for vertex in mesh.fv(face2):
                center2 = center2 + 0.3333333333333333 * np.array([mesh.point(vertex)[0], mesh.point(vertex)[2]])
    
            # Add the new nodes and edge to the dual graph
            dualGraph.add_node(face1.idx(), pos=center1)
            dualGraph.add_node(face2.idx(), pos=center2)
            dualGraph.add_edge(face1.idx(), face2.idx(), idx=edge.idx(), weight=edgeweight) # #might fail without throwing any error ...
           
        
        # Calculate the minimum spanning tree
        spanningTree = nx.minimum_spanning_tree(dualGraph)
    
        # Unfold the tree
        fullUnfolding = self.unfoldSpanningTree(mesh, spanningTree)
        [unfoldedMesh, isFoldingEdge, connections, glueNumber, dihedralAngles] = fullUnfolding
    
    
        # Resolve the intersections
        # Find all intersections
        epsilon = 1E-12  # Accuracy
        faceIntersections = []
        for face1 in unfoldedMesh.faces():
            for face2 in unfoldedMesh.faces():
                if face2.idx() < face1.idx():  # so that we do not double check the couples
                    # Get the triangle faces
                    triangle1 = []
                    triangle2 = []
                    for halfedge in unfoldedMesh.fh(face1):
                        triangle1.append(unfoldedMesh.point(unfoldedMesh.from_vertex_handle(halfedge)))
                    for halfedge in unfoldedMesh.fh(face2):
                        triangle2.append(unfoldedMesh.point(unfoldedMesh.from_vertex_handle(halfedge)))
                    if self.triangleIntersection(triangle1, triangle2, epsilon):
                        faceIntersections.append([connections[face1.idx()], connections[face2.idx()]])
    
        # Find the paths
        # We find the minimum number of cuts to resolve any self-intersection
    
        # Search all paths between overlapping triangles
        paths = []
        for intersection in faceIntersections:
            paths.append(
                nx.algorithms.shortest_paths.shortest_path(spanningTree, source=intersection[0], target=intersection[1]))
    
        # Find all edges in all threads
        edgepaths = []
        for path in paths:
            edgepath = []
            for i in range(len(path) - 1):
                edgepath.append((path[i], path[i + 1]))
            edgepaths.append(edgepath)
    
        # List of all edges in all paths
        allEdgesInPaths = list(set().union(*edgepaths))
    
        # Count how often each edge occurs
        numEdgesInPaths = []
        for edge in allEdgesInPaths:
            num = 0
            for path in edgepaths:
                if edge in path:
                    num = num + 1
            numEdgesInPaths.append(num)
    
        S = []
        C = []
    
        while len(C) != len(paths):
            # Calculate the weights to decide which edge to cut
            cutWeights = np.empty(len(allEdgesInPaths))
            for i in range(len(allEdgesInPaths)):
                currentEdge = allEdgesInPaths[i]
    
                # Count how many of the paths in which the edge occurs have already been cut
                numInC = 0
                for path in C:
                    if currentEdge in path:
                        numInC = numInC + 1
    
                # Determine the weight
                if (numEdgesInPaths[i] - numInC) > 0:
                    cutWeights[i] = 1 / (numEdgesInPaths[i] - numInC)
                else:
                    cutWeights[i] = 1000  # 1000 = infinite
            # Find the edge with the least weight
            minimalIndex = np.argmin(cutWeights)
            S.append(allEdgesInPaths[minimalIndex])
            # Find all paths where the edge occurs and add them to C
            for path in edgepaths:
                if allEdgesInPaths[minimalIndex] in path and not path in C:
                    C.append(path)
    
        # Now we remove the cut edges from the minimum spanning tree
        spanningTree.remove_edges_from(S)
    
        # Find the cohesive components
        connectedComponents = nx.algorithms.components.connected_components(spanningTree)
        connectedComponentList = list(connectedComponents)
    
        # Unfolding of the components
        unfoldings = []
        for component in connectedComponentList:
            unfoldings.append(self.unfoldSpanningTree(mesh, spanningTree.subgraph(component)))
    
    
        return fullUnfolding, unfoldings
    
    
    def findBoundingBox(self, mesh):
        firstpoint = mesh.point(mesh.vertex_handle(0))
        xmin = firstpoint[0]
        xmax = firstpoint[0]
        ymin = firstpoint[1]
        ymax = firstpoint[1]
        for vertex in mesh.vertices():
            coordinates = mesh.point(vertex)
            if (coordinates[0] < xmin):
                xmin = coordinates[0]
            if (coordinates[0] > xmax):
                xmax = coordinates[0]
            if (coordinates[1] < ymin):
                ymin = coordinates[1]
            if (coordinates[1] > ymax):
                ymax = coordinates[1]
        boxSize = np.maximum(np.abs(xmax - xmin), np.abs(ymax - ymin))
    
        return [xmin, ymin, boxSize]
    
    
    def writeSVG(self, unfolding, size, randomColorSet):
        mesh = unfolding[0]
        isFoldingEdge = unfolding[1]
        glueNumber = unfolding[3]
        dihedralAngles = unfolding[4]
    
        #statistic values
        gluePairs = 0
        cuts = 0
        coplanarEdges = 0
        mountainPerforations = 0
        valleyPerforations = 0
        
        # Calculate the bounding box
        [xmin, ymin, boxSize] = self.findBoundingBox(unfolding[0])
    
        if size > 0:
            boxSize = size
    
        strokewidth = boxSize * self.options.fontSize / 8000
        dashLength = boxSize * self.options.fontSize / 2000
        spaceLength = boxSize * self.options.fontSize / 800
        textDistance = boxSize * self.options.fontSize / 800
        textStrokeWidth = boxSize * self.options.fontSize / 3000
        fontsize = boxSize * self.options.fontSize / 1000
        
        # Grouping
        uniqueMainId = self.svg.get_unique_id("")
        
        paperfoldPageGroup = self.document.getroot().add(inkex.Group(id=uniqueMainId + "-paperfold-page"))
        
        textGroup = inkex.Group(id=uniqueMainId + "-text")   
        edgesGroup = inkex.Group(id=uniqueMainId + "-edges")
        paperfoldPageGroup.add(textGroup)
        paperfoldPageGroup.add(edgesGroup) 
        
        textFacesGroup = inkex.Group(id=uniqueMainId + "-textFaces")
        textEdgesGroup = inkex.Group(id=uniqueMainId + "-textEdges")
        textGroup.add(textFacesGroup)
        textGroup.add(textEdgesGroup)
      
        #we could write the unfolded mesh as a 2D stl file to disk if we like:
        if self.options.writeTwoDSTL is True:
            if not os.path.exists(self.options.TwoDSTLdir):
                inkex.utils.debug("Export location for 2D STL unfoldings does not exist. Please select a another dir and try again.")
                exit(1)
            else:
                om.write_mesh(os.path.join(self.options.TwoDSTLdir, uniqueMainId + "-paperfold-page.stl"), mesh)
    
        
        #########################################################
        # Nmbering triangle faces with circle around
        #########################################################
        if self.options.printTriangleNumbers is True:
            for face in mesh.faces():
                centroid = mesh.calc_face_centroid(face) 
                textFaceGroup = inkex.Group(id=uniqueMainId + "-textFace-" + str(face.idx()))
                
                circle = textFaceGroup.add(Circle(cx="{:0.6f}".format(centroid[0]), cy="{:0.6f}".format(centroid[1]), r="{:0.6f}".format(fontsize)))
                circle.set('id', uniqueMainId + "-textFaceCricle-" + str(face.idx()))
                circle.set("style", "stroke:#000000;stroke-width:{:0.6f}".format(strokewidth/2) + ";fill:none")
                
                text = textFaceGroup.add(TextElement(id=uniqueMainId + "-textFaceNumber-" + str(face.idx())))
                text.set("x", "{:0.6f}".format(centroid[0]))
                text.set("y", "{:0.6f}".format(centroid[1] + fontsize / 3))
                text.set("font-size", "{:0.6f}".format(fontsize))
                text.set("style", "stroke-width {:0.6f}".format(textStrokeWidth) + ";text-anchor:middle;text-align:center")
                
                tspan = text.add(Tspan(id=uniqueMainId + "-textFaceNumberTspan-" + str(face.idx())))
                tspan.set("x", "{:0.6f}".format(centroid[0]))
                tspan.set("y", "{:0.6f}".format(centroid[1] + fontsize / 3))
                tspan.set("style", "stroke-width {:0.6f}".format(textStrokeWidth) + ";text-anchor:middle;text-align:center")
                tspan.text = str(face.idx())
                textFacesGroup.append(textFaceGroup)
      
        #########################################################
        # Nmbering triangle edges and style them according to their type
        #########################################################        
        # Go over all edges of the grid
        for edge in mesh.edges():
            # The two endpoints
            he = mesh.halfedge_handle(edge, 0)
            vertex0 = mesh.point(mesh.from_vertex_handle(he))
            vertex1 = mesh.point(mesh.to_vertex_handle(he))
    
            # Write a straight line between the two corners
            line = edgesGroup.add(inkex.PathElement())
            line.set('d', "M {:0.6f},{:0.6f} {:0.6f},{:0.6f}".format(vertex0[0], vertex0[1], vertex1[0], vertex1[1]))
            # Colour depending on folding direction
            lineStyle = {"fill": "none"}
    
            lineStyle.update({"stroke": self.options.colorCutEdges})
            line.set("id", uniqueMainId + "-cut-edge-" + str(edge.idx())) 
                        
            lineStyle.update({"stroke-width": "{:0.6f}".format(strokewidth)})
            lineStyle.update({"stroke-linecap":"butt"})
            lineStyle.update({"stroke-linejoin":"miter"})
            lineStyle.update({"stroke-miterlimit":"4"})  
         
            dihedralAngle = dihedralAngles[edge.idx()]
                
            # Dotted lines for folding edges    
            if isFoldingEdge[edge.idx()]:
                if self.options.dashes is True:
                    lineStyle.update({"stroke-dasharray":"{:0.6f}, {:0.6f}".format(dashLength, spaceLength)})
                if dihedralAngle > 0:
                    lineStyle.update({"stroke": self.options.colorMountainFolds})
                    line.set("id", uniqueMainId + "-mountain-fold-" + str(edge.idx()))
                    mountainPerforations += 1
                if dihedralAngle < 0:
                    lineStyle.update({"stroke": self.options.colorValleyFolds})
                    line.set("id", uniqueMainId + "-valley-fold-" + str(edge.idx()))
                    valleyPerforations += 1
                if dihedralAngle == 0:
                    lineStyle.update({"stroke": self.options.colorCoplanarEdges})
                    line.set("id", uniqueMainId + "-coplanar-edge-" + str(edge.idx()))
                    if self.options.importCoplanarEdges is False:
                        line.delete()
                    coplanarEdges += 1
            else:
                lineStyle.update({"stroke-dasharray":"none"})
    
            # The number of the edge to be glued  
            if not isFoldingEdge[edge.idx()]:
                if self.options.separateGluePairsByColor is True:
                    lineStyle.update({"stroke": randomColorSet[glueNumber[edge.idx()]]})
                gluePairs += 1
                
            lineStyle.update({"stroke-dashoffset":"0.0"})
            lineStyle.update({"stroke-opacity":"1.0"})       
    
            if self.options.edgeStyle == "saturationsForAngles":
                if dihedralAngle != 0: #we dont want to apply HSL adjustments for zero angle lines because they would be invisible then
                    hslColor = inkex.Color(lineStyle.get('stroke')).to_hsl()
                    newSaturation = abs(dihedralAngle / self.angleRange) * 100 #percentage values
                    hslColor.saturation = newSaturation
                    lineStyle.update({"stroke":hslColor.to_rgb()})
    
            elif self.options.edgeStyle == "opacitiesForAngles":
                if dihedralAngle != 0: #we dont want to apply opacity adjustments for zero angle lines because they would be invisible then
                    opacity = abs(dihedralAngle / 180)
                    lineStyle.update({"stroke-opacity": "{:0.6f}".format(opacity)})
    
            line.style = lineStyle
           
            #########################################################
            # Textual things
            #########################################################
            halfEdge = mesh.halfedge_handle(edge, 0) # Find halfedge in the face
            if mesh.face_handle(halfEdge).idx() == -1:
                halfEdge = mesh.opposite_halfedge_handle(halfEdge)
            vector = mesh.calc_edge_vector(halfEdge)
            vector = vector / np.linalg.norm(vector) # normalize
            midPoint = 0.5 * (
                    mesh.point(mesh.from_vertex_handle(halfEdge)) + mesh.point(mesh.to_vertex_handle(halfEdge)))
            rotatedVector = np.array([-vector[1], vector[0], 0])
            angle = np.arctan2(vector[1], vector[0])
            position = midPoint + textDistance * rotatedVector
            if self.options.flipLabels is True:
                position = midPoint - textDistance * rotatedVector
            rotation = 180 / np.pi * angle
            if self.options.flipLabels is True:
                rotation += 180
    
            text = textEdgesGroup.add(TextElement(id=uniqueMainId + "-edgeNumber-" + str(edge.idx())))
            text.set("x", "{:0.6f}".format(position[0]))
            text.set("y", "{:0.6f}".format(position[1]))
            text.set("font-size", "{:0.6f}".format(fontsize))
            text.set("style", "stroke-width {:0.6f}".format(textStrokeWidth) + ";text-anchor:middle;text-align:center")
            text.set("transform", "rotate({:0.6f} {:0.6f} {:0.6f})".format(rotation, position[0], position[1]))
            
            tspan = text.add(Tspan())
            tspan.set("x", "{:0.6f}".format(position[0]))
            tspan.set("y", "{:0.6f}".format(position[1]))
            tspan.set("style", "stroke-width {:0.6f}".format(textStrokeWidth) + ";text-anchor:middle;text-align:center")
            tspanText = []
            if self.options.printGluePairNumbers is True and not isFoldingEdge[edge.idx()]:
                tspanText.append(str(glueNumber[edge.idx()]))
            if self.options.printAngles is True:
                tspanText.append("{:0.2f}°".format(dihedralAngle))
            if self.options.printLengths is True:
                printUnit = True
                if printUnit is False:
                    unitToPrint = self.svg.unit
                else:
                    unitToPrint = ""
                tspanText.append("{:0.2f} {}".format(self.options.scalefactor * math.hypot(vertex1[0] - vertex0[0], vertex1[1] - vertex0[1]), unitToPrint))
            tspan.text = " | ".join(tspanText)
    
            if tspan.text == "": #if no text we remove again to clean up
                text.delete()
                tspan.delete()
 
        if len(textFacesGroup) == 0:
            textFacesGroup.delete() #delete if empty set
            
        if len(textEdgesGroup) == 0:
            textEdgesGroup.delete() #delete if empty set
            
        if len(textGroup) == 0:
            textGroup.delete() #delete if empty set
              
        if self.options.printStats is True:
            inkex.utils.debug(" * Number of cuts: " + str(cuts))
            inkex.utils.debug(" * Number of coplanar edges: " + str(coplanarEdges))
            inkex.utils.debug(" * Number of mountain folds: " + str(mountainPerforations))
            inkex.utils.debug(" * Number of valley folds: " + str(valleyPerforations))
            inkex.utils.debug(" * Number of glue pairs: {:0.0f}".format(gluePairs / 2))
            inkex.utils.debug(" * min angle: {:0.2f}".format(self.minAngle))
            inkex.utils.debug(" * max angle: {:0.2f}".format(self.maxAngle))
            inkex.utils.debug(" * Edge angle range: {:0.2f}".format(self.angleRange))
                        
        return paperfoldPageGroup
                
    def add_arguments(self, pars):
        pars.add_argument("--tab")
        
        #Input
        pars.add_argument("--inputfile")
        pars.add_argument("--maxNumFaces", type=int, default=200, help="If the STL file has too much detail it contains a large number of faces. This will make unfolding extremely slow. So we can limit it.")
        pars.add_argument("--scalefactor", type=float, default=1.0, help="Manual scale factor")
        pars.add_argument("--roundingDigits", type=int, default=3, help="Digits for rounding")

        #Output
        pars.add_argument("--printGluePairNumbers", type=inkex.Boolean, default=False, help="Print glue pair numbers on cut edges")
        pars.add_argument("--printAngles", type=inkex.Boolean, default=False, help="Print folding angles on edges")
        pars.add_argument("--printLengths", type=inkex.Boolean, default=False, help="Print lengths on edges")
        pars.add_argument("--printTriangleNumbers", type=inkex.Boolean, default=False, help="Print triangle numbers on faces")
        pars.add_argument("--importCoplanarEdges", type=inkex.Boolean, default=False, help="Import coplanar edges")
        pars.add_argument("--printStats", type=inkex.Boolean, default=False, help="Show some unfold statistics")
        pars.add_argument("--resizetoimport", type=inkex.Boolean, default=True, help="Resize the canvas to the imported drawing's bounding box") 
        pars.add_argument("--extraborder", type=float, default=0.0)
        pars.add_argument("--extraborderUnits")
        pars.add_argument("--writeTwoDSTL", type=inkex.Boolean, default=False, help="Write 2D STL unfoldings")
        pars.add_argument("--TwoDSTLdir", default="./inkscape_export/", help="Location to save exported 2D STL")

        #Style 
        pars.add_argument("--fontSize", type=int, default=15, help="Label font size (%)")
        pars.add_argument("--flipLabels", type=inkex.Boolean, default=False, help="Flip labels")
        pars.add_argument("--dashes", type=inkex.Boolean, default=True, help="Dashes for cut/coplanar edges")
        pars.add_argument("--edgeStyle", help="Adjust color saturation or opacity for folding edges. The larger the angle the darker the color")
        pars.add_argument("--separateGluePairsByColor", type=inkex.Boolean, default=False, help="Separate glue pairs by color")
        pars.add_argument("--colorCutEdges", type=Color, default='255', help="Cut edges")
        pars.add_argument("--colorCoplanarEdges", type=Color, default='1943148287', help="Coplanar edges")
        pars.add_argument("--colorValleyFolds", type=Color, default='3422552319', help="Valley fold edges")
        pars.add_argument("--colorMountainFolds", type=Color, default='879076607', help="Mountain fold edges")
        
        #Post Processing
        pars.add_argument("--joineryMode", type=inkex.Boolean, default=False, help="Enable joinery mode")
        pars.add_argument("--origamiSimulatorMode", type=inkex.Boolean, default=False, help="Enable origami simulator mode")
               
    def effect(self):
        if not os.path.exists(self.options.inputfile):
            inkex.utils.debug("The input file does not exist. Please select a proper file and try again.")
            exit(1)
        mesh = om.read_trimesh(self.options.inputfile)
        #mesh = om.read_polymesh(self.options.inputfile) #we must work with triangles instead of polygons because the algorithm works with that

        fullUnfolded, unfoldedComponents = self.unfold(mesh)
 
 
        #if len(unfoldedComponents) == 0:
        #    inkex.utils.debug("Error: no components were unfolded.")
        #    exit(1)
 
        if self.options.printStats is True:
            inkex.utils.debug("Unfolding components: {:0.0f}".format(len(unfoldedComponents)))
        
        # Compute maxSize of the components
        # All components must be scaled to the same size as the largest component
        maxSize = 0
        for unfolding in unfoldedComponents:
            [xmin, ymin, boxSize] = self.findBoundingBox(unfolding[0])
            if boxSize > maxSize:
                maxSize = boxSize
                     
        #########################################################
        # mode config for joinery:
        #########################################################
        if self.options.joineryMode is True:
            self.options.separateGluePairsByColor = True #we need random colors in this mode
             
             
        #########################################################
        # mode config for origami simulator:
        #########################################################
            '''
            required style for Origami Simulator:
            colors:
             - #ff0000 (red)     - mountain folds
             - #0000ff (blue)    - valley folds
             - #000000 (black)   - boundary cuts (for both the outline of the pattern and any internal holes)
             - #ffff00 (yellow)  - coplonar triangle edges ("facet creases") (no support for polygons > 3 edges)
             - #00ff00 (green)   - thin slits
             - #ff00ff (magenta) - undriven creases (swing freely)

            opacity:
             - final fold angle of a mountain or valley fold is set by its opacity. Any fold angle between 0° and 180° may be used. For example:
                  - 1.0 = 180° (fully folded)
                  - 0.5 = 90°
                  - 0 = 0° (flat)
            '''      
        if self.options.origamiSimulatorMode is True:
            self.options.joineryMode = True #we set to true even if false because we need the same flat structure for origami simulator
            self.options.separateGluePairsByColor = False #we need to have no weird random colors in this mode
            self.options.edgeStyle = "opacitiesForAngles" #highly important for simulation
            self.options.importCoplanarEdges = True
            self.options.colorCutEdges = "#000000" #black
            self.options.colorCoplanarEdges = "#ffff00" #yellow
            self.options.colorMountainFolds = "#ff0000" #red
            self.options.colorValleyFolds = "#0000ff" #blue
 
        #generate random colors; used to identify glue tab pairs
        randomColorSet = []
        if self.options.separateGluePairsByColor:
            while len(randomColorSet) < len(mesh.edges()):
                r = lambda: random.randint(0,255)
                newColor = '#%02X%02X%02X' % (r(),r(),r())
                if newColor not in randomColorSet:
                    randomColorSet.append(newColor)
                  
        # Create a new container group to attach all paperfolds
        paperfoldMainGroup = self.document.getroot().add(inkex.Group(id=self.svg.get_unique_id("paperfold-"))) #make a new group at root level
        for i in range(len(unfoldedComponents)):
            if self.options.printStats is True:
                inkex.utils.debug("-----------------------------------------------------------")
                inkex.utils.debug("Unfolding component nr.: {:0.0f}".format(i))
            paperfoldPageGroup = self.writeSVG(unfoldedComponents[i], maxSize, randomColorSet)
            #translate the groups next to each other to remove overlappings
            if i != 0:
                previous_bbox = paperfoldMainGroup[i-1].bounding_box()
                this_bbox = paperfoldPageGroup.bounding_box()
                paperfoldPageGroup.set("transform","translate({:0.6f}, 0.0)".format(previous_bbox.left + previous_bbox.width - this_bbox.left))
            paperfoldMainGroup.append(paperfoldPageGroup) 

        
        #apply scale factor
        translation_matrix = [[self.options.scalefactor, 0.0, 0.0], [0.0, self.options.scalefactor, 0.0]]            
        paperfoldMainGroup.transform = Transform(translation_matrix) * paperfoldMainGroup.transform
        #paperfoldMainGroup.set('transform', 'scale(%f,%f)' % (self.options.scalefactor, self.options.scalefactor))

        #adjust canvas to the inserted unfolding
        if self.options.resizetoimport:
            bbox = paperfoldMainGroup.bounding_box()
            namedView = self.document.getroot().find(inkex.addNS('namedview', 'sodipodi'))
            root = self.svg.getElement('//svg:svg');
            offset = self.svg.unittouu(str(self.options.extraborder) + self.options.extraborderUnits)
            root.set('viewBox', '%f %f %f %f' % (bbox.left - offset, bbox.top - offset, bbox.width + 2 * offset, bbox.height + 2 * offset))
            root.set('width', "{:0.6f}{}".format(bbox.width + 2 * offset, self.svg.unit))
            root.set('height', "{:0.6f}{}".format(bbox.height + 2 * offset, self.svg.unit))

        #if set, we move all edges (path elements) to the top level
        if self.options.joineryMode is True:
            for paperfoldPage in paperfoldMainGroup.getchildren():
                for child in paperfoldPage:
                    if "-edges" in child.get('id'):
                        for edge in child:
                            edgeTransform = edge.composed_transform()
                            self.document.getroot().append(edge)
                            edge.transform = edgeTransform


if __name__ == '__main__':
    Unfold().run()