forked from bartvdbraak/blender
1594 lines
46 KiB
Python
1594 lines
46 KiB
Python
#!BPY
|
|
"""
|
|
Name: 'Unfold'
|
|
Blender: 243
|
|
Group: 'Mesh'
|
|
Tip: 'Unfold meshes to create nets'
|
|
Version: v2.2.4
|
|
Author: Matthew Chadwick
|
|
"""
|
|
import Blender
|
|
from Blender import *
|
|
from Blender.Mathutils import *
|
|
try:
|
|
import sys
|
|
import traceback
|
|
import math
|
|
import re
|
|
from math import *
|
|
import sys
|
|
import random
|
|
from decimal import *
|
|
import xml.sax, xml.sax.handler, xml.sax.saxutils
|
|
|
|
except:
|
|
print "One of the Python modules required can't be found."
|
|
print sys.exc_info()[1]
|
|
traceback.print_exc(file=sys.stdout)
|
|
|
|
__author__ = 'Matthew Chadwick'
|
|
__version__ = '2.2.4 24032007'
|
|
__url__ = ["http://celeriac.net/unfolder/", "blender", "blenderartist"]
|
|
__email__ = ["post at cele[remove this text]riac.net", "scripts"]
|
|
__bpydoc__ = """\
|
|
|
|
Mesh Unfolder
|
|
|
|
Unfolds the selected mesh onto a plane to form a net
|
|
|
|
Not all meshes can be unfolded
|
|
|
|
Meshes must be free of holes,
|
|
isolated edges (not part of a face), twisted quads and other rubbish.
|
|
Nice clean triangulated meshes unfold best
|
|
|
|
This program is free software; you can distribute it and/or modify it under the terms
|
|
of the GNU General Public License as published by the Free Software Foundation; version 2
|
|
or later, currently at http://www.gnu.org/copyleft/gpl.html
|
|
|
|
The idea came while I was riding a bike.
|
|
|
|
"""
|
|
|
|
# Face lookup
|
|
class FacesAndEdges:
|
|
def __init__(self, mesh):
|
|
self.nfaces = 0
|
|
# straight from the documentation
|
|
self.edgeFaces = dict([(edge.key, []) for edge in mesh.edges])
|
|
for face in mesh.faces:
|
|
face.sel = False
|
|
for key in face.edge_keys:
|
|
self.edgeFaces[key].append(face)
|
|
def findTakenAdjacentFace(self, bface, edge):
|
|
return self.findAdjacentFace(bface, edge)
|
|
# find the first untaken (non-selected) adjacent face in the list of adjacent faces for the given edge
|
|
def findAdjacentFace(self, bface, edge):
|
|
faces = self.edgeFaces[edge.key()]
|
|
for i in xrange(len(faces)):
|
|
if faces[i] == bface:
|
|
j = (i+1) % len(faces)
|
|
while(faces[j]!=bface):
|
|
if faces[j].sel == False:
|
|
return faces[j]
|
|
j = (j+1) % len(faces)
|
|
return None
|
|
def returnFace(self, face):
|
|
face.sel = False
|
|
self.nfaces-=1
|
|
def facesTaken(self):
|
|
return self.nfaces
|
|
def takeAdjacentFace(self, bface, edge):
|
|
if (edge==None):
|
|
return None
|
|
face = self.findAdjacentFace(bface, edge)
|
|
if(face!=None):
|
|
face.sel = True
|
|
self.nfaces+=1
|
|
return face
|
|
def takeFace(self, bface):
|
|
if(bface!=None):
|
|
bface.sel= True
|
|
self.nfaces+=1
|
|
|
|
|
|
class IntersectionResult:
|
|
def __init__(self, rn, rd, v=None):
|
|
self.v = v
|
|
self.rd = rd
|
|
self.rn = rn
|
|
def intersected(self):
|
|
return not(not(self.v))
|
|
def isParallel(self):
|
|
return (self.rd==0)
|
|
def isColinear(self):
|
|
return (self.rn==0)
|
|
def intersection(self):
|
|
return self.v
|
|
|
|
# represents a line segment between two points [p1, p2]. the points are [x,y]
|
|
class LineSegment:
|
|
def __init__(self, p):
|
|
self.p = p
|
|
def intersects(self, s):
|
|
rn = ((self.p[0].y-s.p[0].y)*(s.p[1].x-s.p[0].x)-(self.p[0].x-s.p[0].x)*(s.p[1].y-s.p[0].y))
|
|
rd = ((self.p[1].x-self.p[0].x)*(s.p[1].y-s.p[0].y)-(self.p[1].y-self.p[0].y)*(s.p[1].x-s.p[0].x))
|
|
# need an epsilon closeTo() here
|
|
if(rd<0.0000001 or rn==0.0):
|
|
return IntersectionResult(rn,rd)
|
|
r = rn/rd
|
|
s = ((self.p[0].y-s.p[0].y)*(self.p[1].x-self.p[0].x)-(self.p[0].x-s.p[0].x)*(self.p[1].y-self.p[0].y)) / rd
|
|
i = (0.0<=r and r<=1.0 and 0.0<=s and s<=1.0)
|
|
if not(i):
|
|
return None
|
|
ix = self.p[0].x + r*(self.p[1].x - self.p[0].x)
|
|
iy = self.p[0].y + r*(self.p[1].y - self.p[0].y)
|
|
t = 0.0001
|
|
if ( abs(ix-self.p[0].x)>t and abs(iy-self.p[0].x)>t and abs(ix-self.p[1].x)>t and abs(iy-self.p[1].y)>t ):
|
|
return IntersectionResult( rn, rd,Vector([ix,iy,0.0]))
|
|
else:
|
|
return None
|
|
|
|
class LineSegments:
|
|
def __init__(self, face):
|
|
self.face = face
|
|
def segmentAt(self, i):
|
|
if(i>self.face.nPoints()-1):
|
|
return None
|
|
if(i==self.face.nPoints()-1):
|
|
j = 0
|
|
else:
|
|
j = i+1
|
|
return LineSegment([ self.face.v[i], self.face.v[j] ])
|
|
def iterateSegments(self, something):
|
|
results = []
|
|
for i in xrange(self.face.nPoints()):
|
|
results.extend(something.haveSegment(self.segmentAt(i)))
|
|
return results
|
|
def compareSegments(self, something, segment):
|
|
results = []
|
|
for i in xrange(self.face.nPoints()):
|
|
results.append(something.compareSegments([self.segmentAt(i), segment]))
|
|
return results
|
|
|
|
class FaceOverlapTest:
|
|
def __init__(self, face1, face2):
|
|
self.faces = [face1, face2]
|
|
self.segments = [ LineSegments(self.faces[0]), LineSegments(self.faces[1]) ]
|
|
def suspectsOverlap(self):
|
|
tests = self.segments[0].iterateSegments(self)
|
|
gi = 0
|
|
for i in tests:
|
|
if( i!=None and i.intersected() ):
|
|
gi+=1
|
|
return gi>0
|
|
def haveSegment(self, segment):
|
|
return self.segments[1].compareSegments(self, segment)
|
|
def compareSegments(self, segments):
|
|
return segments[0].intersects(segments[1])
|
|
|
|
|
|
|
|
# A fold between two faces with a common edge
|
|
class Fold:
|
|
ids = -1
|
|
def __init__(self, parent, refPoly, poly, edge, angle=None):
|
|
Fold.ids+=1
|
|
self.id = Fold.ids
|
|
self.refPoly = refPoly
|
|
self.poly = poly
|
|
self.srcFace = None
|
|
self.desFace = None
|
|
self.edge = edge
|
|
self.foldedEdge = edge
|
|
self.rm = None
|
|
self.parent = parent
|
|
self.tree = None
|
|
if(refPoly!=None):
|
|
self.refPolyNormal = refPoly.normal()
|
|
self.polyNormal = poly.normal()
|
|
if(angle==None):
|
|
self.angle = self.calculateAngle()
|
|
self.foldingPoly = poly.rotated(edge, self.angle)
|
|
else:
|
|
self.angle = angle
|
|
self.foldingPoly = poly
|
|
self.unfoldedEdge = self.edge
|
|
self.unfoldedNormal = None
|
|
self.animAngle = self.angle
|
|
self.cr = None
|
|
self.nancestors = None
|
|
def reset(self):
|
|
self.foldingPoly = self.poly.rotated(self.edge, self.dihedralAngle())
|
|
def getID(self):
|
|
return self.id
|
|
def getParent(self):
|
|
return self.parent
|
|
def ancestors(self):
|
|
if(self.nancestors==None):
|
|
self.nancestors = self.computeAncestors()
|
|
return self.nancestors
|
|
def computeAncestors(self):
|
|
if(self.parent==None):
|
|
return 0
|
|
else:
|
|
return self.parent.ancestors()+1
|
|
def dihedralAngle(self):
|
|
return self.angle
|
|
def unfoldTo(self, f):
|
|
self.animAngle = self.angle*f
|
|
self.foldingPoly = self.poly.rotated(self.edge, self.animAngle)
|
|
def calculateAngle(self):
|
|
sangle = Mathutils.AngleBetweenVecs(self.refPolyNormal, self.polyNormal)
|
|
if(sangle!=sangle):
|
|
sangle=0.0
|
|
ncp = Mathutils.CrossVecs(self.refPolyNormal, self.polyNormal)
|
|
dp = Mathutils.DotVecs(ncp, self.edge.vector)
|
|
if(dp>0.0):
|
|
return +sangle
|
|
else:
|
|
return -sangle
|
|
def alignWithParent(self):
|
|
pass
|
|
def unfoldedNormal(self):
|
|
return self.unfoldedNormal
|
|
def getEdge(self):
|
|
return self.edge
|
|
def getFace(self):
|
|
return self.poly
|
|
def testFace(self):
|
|
return Poly.fromVectors([self.edge.v1, self.edge.v2, Vector([0,0,0])])
|
|
def unfoldedFace(self):
|
|
return self.foldingPoly
|
|
def unfold(self):
|
|
if(self.parent!=None):
|
|
self.parent.foldFace(self)
|
|
def foldFace(self, child):
|
|
child.foldingPoly.rotate(self.edge, self.animAngle)
|
|
if(self.parent!=None):
|
|
self.parent.foldFace(child)
|
|
|
|
class Cut(Fold):
|
|
pass
|
|
|
|
# Trees build folds by traversing the mesh according to a local measure
|
|
class Tree:
|
|
def __init__(self, net, parent,fold,otherConstructor=None):
|
|
self.net = net
|
|
self.fold = fold
|
|
self.face = fold.srcFace
|
|
self.poly = Poly.fromBlenderFace(self.face)
|
|
self.generations = net.generations
|
|
self.growing = True
|
|
self.tooLong = False
|
|
self.parent = parent
|
|
self.grown = False
|
|
if not(otherConstructor):
|
|
self.edges = net.edgeIteratorClass(self)
|
|
def goodness(self):
|
|
return self.edges.goodness()
|
|
def compare(self, other):
|
|
if(self.goodness() > other.goodness()):
|
|
return +1
|
|
else:
|
|
return -1
|
|
def isGrowing(self):
|
|
return self.growing
|
|
def beGrowing(self):
|
|
self.growing = True
|
|
def grow(self):
|
|
self.tooLong = self.fold.ancestors()>self.generations
|
|
if(self.edges.hasNext() and self.growing):
|
|
edge = self.edges.next()
|
|
tface = self.net.facesAndEdges.takeAdjacentFace(self.face, edge)
|
|
if(tface!=None):
|
|
self.branch(tface, edge)
|
|
if(self.parent==None):
|
|
self.grow()
|
|
else:
|
|
self.grown = True
|
|
def isGrown(self):
|
|
return self.grown
|
|
def canGrow(self):
|
|
return (self.parent!=None and self.parent.grown)
|
|
def getNet(self):
|
|
return self.net
|
|
def getFold(self):
|
|
return self.fold
|
|
def getFace(self):
|
|
return self.face
|
|
def branch(self, tface, edge):
|
|
fold = Fold(self.fold, self.poly, Poly.fromBlenderFace(tface), edge)
|
|
fold.srcFace = tface
|
|
self.net.myFacesVisited+=1
|
|
tree = Tree(self.net, self, fold)
|
|
fold.tree = tree
|
|
fold.unfold()
|
|
overlaps = self.net.checkOverlaps(fold)
|
|
nc = len(overlaps)
|
|
self.net.overlaps+=nc
|
|
if(nc>0 and self.net.avoidsOverlaps):
|
|
self.handleOverlap(fold, overlaps)
|
|
else:
|
|
self.addFace(fold)
|
|
def handleOverlap(self, fold, overlaps):
|
|
self.net.facesAndEdges.returnFace(fold.srcFace)
|
|
self.net.myFacesVisited-=1
|
|
for cfold in overlaps:
|
|
ttree = cfold.tree
|
|
ttree.growing = True
|
|
ttree.grow()
|
|
def addFace(self, fold):
|
|
ff = fold.unfoldedFace()
|
|
fold.desFace = self.net.addFace(ff, fold.srcFace)
|
|
self.net.folds.append(fold)
|
|
self.net.addBranch(fold.tree)
|
|
fold.tree.growing = not(self.tooLong)
|
|
if(self.net.diffuse==False):
|
|
fold.tree.grow()
|
|
|
|
# A Net is the result of the traversal of the mesh by Trees
|
|
class Net:
|
|
def __init__(self, src, des):
|
|
self.src = src
|
|
self.des = des
|
|
self.firstFace = None
|
|
self.firstPoly = None
|
|
self.refFold = None
|
|
self.edgeIteratorClass = RandomEdgeIterator
|
|
if(src!=None):
|
|
self.srcFaces = src.faces
|
|
self.facesAndEdges = FacesAndEdges(self.src)
|
|
self.myFacesVisited = 0
|
|
self.facesAdded = 0
|
|
self.folds = []
|
|
self.cuts = []
|
|
self.branches = []
|
|
self.overlaps = 0
|
|
self.avoidsOverlaps = True
|
|
self.frame = 1
|
|
self.ff = 180.0
|
|
self.firstFaceIndex = None
|
|
self.trees = 0
|
|
self.foldIPO = None
|
|
self.perFoldIPO = None
|
|
self.IPOCurves = {}
|
|
self.generations = 128
|
|
self.diffuse = True
|
|
self.noise = 0.0
|
|
self.grownBranches = 0
|
|
self.assignsUV = True
|
|
self.animates = False
|
|
self.showProgress = False
|
|
self.feedback = None
|
|
def setSelectedFaces(self, faces):
|
|
self.srcFaces = faces
|
|
self.facesAndEdges = FacesAndEdges(self.srcFaces)
|
|
def setShowProgress(self, show):
|
|
self.showProgress = show
|
|
# this method really needs work
|
|
def unfold(self):
|
|
selectedFaces = [face for face in self.src.faces if (self.src.faceUV and face.flag & Mesh.FaceFlags.SELECT)]
|
|
if(self.avoidsOverlaps):
|
|
print "unfolding with overlap detection"
|
|
if(self.firstFaceIndex==None):
|
|
self.firstFaceIndex = random.randint(0, len(self.src.faces)-1)
|
|
else:
|
|
print "Using user-selected seed face ", self.firstFaceIndex
|
|
self.firstFace = self.src.faces[self.firstFaceIndex]
|
|
z = min([v.co.z for v in self.src.verts])-0.1
|
|
ff = Poly.fromBlenderFace(self.firstFace)
|
|
if(len(ff.v)<3):
|
|
raise Exception("This mesh contains an isolated edge - it must consist only of faces")
|
|
testFace = Poly.fromVectors( [ Vector([0.0,0.0,0.0]), Vector([0.0,1.0,0.0]), Vector([1.0,1.0,0.0]) ] )
|
|
# hmmm
|
|
u=0
|
|
v=1
|
|
w=2
|
|
if ff.v[u].x==ff.v[u+1].x and ff.v[u].y==ff.v[u+1].y:
|
|
u=1
|
|
v=2
|
|
w=0
|
|
# here we make a couple of folds, not part of the net, which serve to get the net into the xy plane
|
|
xyFace = Poly.fromList( [ [ff.v[u].x,ff.v[u].y, z] , [ff.v[v].x,ff.v[v].y, z] , [ff.v[w].x+0.1,ff.v[w].y+0.1, z] ] )
|
|
refFace = Poly.fromVectors([ ff.v[u], ff.v[v], xyFace.v[1], xyFace.v[0] ] )
|
|
xyFold = Fold(None, xyFace, refFace, Edge(xyFace.v[0], xyFace.v[1] ))
|
|
self.refFold = Fold(xyFold, refFace, ff, Edge(refFace.v[0], refFace.v[1] ))
|
|
self.refFold.srcFace = self.firstFace
|
|
trunk = Tree(self, None, self.refFold)
|
|
trunk.generations = self.generations
|
|
self.firstPoly = ff
|
|
self.facesAndEdges.takeFace(self.firstFace)
|
|
self.myFacesVisited+=1
|
|
self.refFold.unfold()
|
|
self.refFold.tree = trunk
|
|
self.refFold.desFace = self.addFace(self.refFold.unfoldedFace(), self.refFold.srcFace)
|
|
self.folds.append(self.refFold)
|
|
trunk.grow()
|
|
i = 0
|
|
while(self.myFacesVisited<len(self.src.faces) and len(self.branches) > 0):
|
|
if self.edgeIteratorClass==RandomEdgeIterator:
|
|
i = random.randint(0,len(self.branches)-1)
|
|
tree = self.branches[i]
|
|
if(tree.isGrown()):
|
|
self.branches.pop(i)
|
|
else:
|
|
tree.beGrowing()
|
|
if(tree.canGrow()):
|
|
tree.grow()
|
|
i = 0
|
|
else:
|
|
i = (i + 1) % len(self.branches)
|
|
if self.src.faceUV:
|
|
for face in self.src.faces:
|
|
face.sel = False
|
|
for face in selectedFaces:
|
|
face.sel = True
|
|
self.src.update()
|
|
Window.RedrawAll()
|
|
def assignUVs(self):
|
|
for fold in self.folds:
|
|
self.assignUV(fold.srcFace, fold.unfoldedFace())
|
|
print " assigned uv to ", len(self.folds), len(self.src.faces)
|
|
self.src.update()
|
|
def checkOverlaps(self, fold):
|
|
#return self.getOverlapsBetween(fold, self.folds)
|
|
return self.getOverlapsBetweenGL(fold, self.folds)
|
|
def getOverlapsBetween(self, fold, folds):
|
|
if(fold.parent==None):
|
|
return []
|
|
mf = fold.unfoldedFace()
|
|
c = []
|
|
for afold in folds:
|
|
mdf = afold.unfoldedFace()
|
|
if(afold!=fold):
|
|
it1 = FaceOverlapTest(mf, mdf)
|
|
it2 = FaceOverlapTest(mdf, mf)
|
|
overlap = (it1.suspectsOverlap() or it2.suspectsOverlap())
|
|
inside = ( mdf.containsAnyOf(mf) or mf.containsAnyOf(mdf) )
|
|
if( overlap or inside or mdf.overlays(mf)):
|
|
c.append(afold)
|
|
return c
|
|
def getOverlapsBetweenGL(self, fold, folds):
|
|
b = fold.unfoldedFace().bounds()
|
|
polys = len(folds)*4+16 # the buffer is nhits, mindepth, maxdepth, name
|
|
buffer = BGL.Buffer(BGL.GL_INT, polys)
|
|
BGL.glSelectBuffer(polys, buffer)
|
|
BGL.glRenderMode(BGL.GL_SELECT)
|
|
BGL.glInitNames()
|
|
BGL.glPushName(0)
|
|
BGL.glPushMatrix()
|
|
BGL.glMatrixMode(BGL.GL_PROJECTION)
|
|
BGL.glLoadIdentity()
|
|
BGL.glOrtho(b[0].x, b[1].x, b[1].y, b[0].y, 0.0, 10.0)
|
|
#clip = BGL.Buffer(BGL.GL_FLOAT, 4)
|
|
#clip.list = [0,0,0,0]
|
|
#BGL.glClipPlane(BGL.GL_CLIP_PLANE1, clip)
|
|
# could use clipping planes here too
|
|
BGL.glMatrixMode(BGL.GL_MODELVIEW)
|
|
BGL.glLoadIdentity()
|
|
bx = (b[1].x - b[0].x)
|
|
by = (b[1].y - b[0].y)
|
|
cx = bx / 2.0
|
|
cy = by / 2.0
|
|
for f in xrange(len(folds)):
|
|
afold = folds[f]
|
|
if(fold!=afold):
|
|
BGL.glLoadName(f)
|
|
BGL.glBegin(BGL.GL_LINE_LOOP)
|
|
for v in afold.unfoldedFace().v:
|
|
BGL.glVertex2f(v.x, v.y)
|
|
BGL.glEnd()
|
|
BGL.glPopMatrix()
|
|
BGL.glFlush()
|
|
hits = BGL.glRenderMode(BGL.GL_RENDER)
|
|
buffer = [buffer[i] for i in xrange(3, 4*hits, 4)]
|
|
o = [folds[buffer[i]] for i in xrange(len(buffer))]
|
|
return self.getOverlapsBetween(fold, o)
|
|
def colourFace(self, face, cr):
|
|
for c in face.col:
|
|
c.r = int(cr[0])
|
|
c.g = int(cr[1])
|
|
c.b = int(cr[2])
|
|
c.a = int(cr[3])
|
|
self.src.update()
|
|
def setAvoidsOverlaps(self, avoids):
|
|
self.avoidsOverlaps = avoids
|
|
def addBranch(self, branch):
|
|
self.branches.append(branch)
|
|
if self.edgeIteratorClass!=RandomEdgeIterator:
|
|
self.branches.sort(lambda b1, b2: b1.compare(b2))
|
|
def srcSize(self):
|
|
return len(self.src.faces)
|
|
def nBranches(self):
|
|
return len(self.branches)
|
|
def facesCreated(self):
|
|
return len(self.des.faces)
|
|
def facesVisited(self):
|
|
return self.myFacesVisited
|
|
def getOverlaps(self):
|
|
return self.overlaps
|
|
def sortOutIPOSource(self):
|
|
print "Sorting out IPO"
|
|
if self.foldIPO!=None:
|
|
return
|
|
o = None
|
|
try:
|
|
o = Blender.Object.Get("FoldRate")
|
|
except:
|
|
o = Blender.Object.New("Empty", "FoldRate")
|
|
Blender.Scene.GetCurrent().objects.link(o)
|
|
if(o.getIpo()==None):
|
|
ipo = Blender.Ipo.New("Object", "FoldRateIPO")
|
|
z = ipo.addCurve("RotZ")
|
|
print " added RotZ IPO curve"
|
|
z.addBezier((1,0))
|
|
# again, why is this 10x out ?
|
|
z.addBezier((180, self.ff/10.0))
|
|
z.addBezier((361, 0.0))
|
|
o.setIpo(ipo)
|
|
z.recalc()
|
|
z.setInterpolation("Bezier")
|
|
z.setExtrapolation("Cyclic")
|
|
self.setIPOSource(o)
|
|
print " added IPO source"
|
|
def setIPOSource(self, object):
|
|
try:
|
|
self.foldIPO = object
|
|
for i in xrange(self.foldIPO.getIpo().getNcurves()):
|
|
self.IPOCurves[self.foldIPO.getIpo().getCurves()[i].getName()] = i
|
|
print " added ", self.foldIPO.getIpo().getCurves()[i].getName()
|
|
except:
|
|
print "Problem setting IPO object"
|
|
print sys.exc_info()[1]
|
|
traceback.print_exc(file=sys.stdout)
|
|
def setFoldFactor(self, ff):
|
|
self.ff = ff
|
|
def sayTree(self):
|
|
for fold in self.folds:
|
|
if(fold.getParent()!=None):
|
|
print fold.getID(), fold.dihedralAngle(), fold.getParent().getID()
|
|
def report(self):
|
|
p = int(float(self.myFacesVisited)/float(len(self.src.faces)) * 100)
|
|
print str(p) + "% unfolded"
|
|
print "faces created:", self.facesCreated()
|
|
print "faces visited:", self.facesVisited()
|
|
print "originalfaces:", len(self.src.faces)
|
|
n=0
|
|
if(self.avoidsOverlaps):
|
|
print "net avoided at least ", self.getOverlaps(), " overlaps ",
|
|
n = len(self.src.faces) - self.facesCreated()
|
|
if(n>0):
|
|
print "but was unable to avoid ", n, " overlaps. Incomplete net."
|
|
else:
|
|
print "- A complete net."
|
|
else:
|
|
print "net has at least ", self.getOverlaps(), " collision(s)"
|
|
return n
|
|
# fold all my folds to a fraction of their total fold angle
|
|
def unfoldToCurrentFrame(self):
|
|
self.unfoldTo(Blender.Scene.GetCurrent().getRenderingContext().currentFrame())
|
|
def unfoldTo(self, frame):
|
|
frames = Blender.Scene.GetCurrent().getRenderingContext().endFrame()
|
|
if(self.foldIPO!=None and self.foldIPO.getIpo()!=None):
|
|
f = self.foldIPO.getIpo().EvaluateCurveOn(self.IPOCurves["RotZ"],frame)
|
|
# err, this number seems to be 10x less than it ought to be
|
|
fff = 1.0 - (f*10.0 / self.ff)
|
|
else:
|
|
fff = 1.0-((frame)/(frames*1.0))
|
|
for fold in self.folds:
|
|
fold.unfoldTo(fff)
|
|
for fold in self.folds:
|
|
fold.unfold()
|
|
tface = fold.unfoldedFace()
|
|
bface = fold.desFace
|
|
i = 0
|
|
for v in bface.verts:
|
|
v.co.x = tface.v[i].x
|
|
v.co.y = tface.v[i].y
|
|
v.co.z = tface.v[i].z
|
|
i+=1
|
|
Window.Redraw(Window.Types.VIEW3D)
|
|
return None
|
|
def addFace(self, poly, originalFace=None):
|
|
originalLength = len(self.des.verts)
|
|
self.des.verts.extend([Vector(vv.x, vv.y, vv.z) for vv in poly.v])
|
|
self.des.faces.extend([ range(originalLength, originalLength + poly.size()) ])
|
|
newFace = self.des.faces[len(self.des.faces)-1]
|
|
newFace.uv = [vv for vv in poly.v]
|
|
if(originalFace!=None and self.src.vertexColors):
|
|
newFace.col = [c for c in originalFace.col]
|
|
if(self.feedback!=None):
|
|
pu = str(int(self.fractionUnfolded() * 100))+"% unfolded"
|
|
howMuchDone = str(self.myFacesVisited)+" of "+str(len(self.src.faces))+" "+pu
|
|
self.feedback.say(howMuchDone)
|
|
#Window.DrawProgressBar (p, pu)
|
|
if(self.showProgress):
|
|
Window.Redraw(Window.Types.VIEW3D)
|
|
return newFace
|
|
def fractionUnfolded(self):
|
|
return float(self.myFacesVisited)/float(len(self.src.faces))
|
|
def assignUV(self, face, uv):
|
|
face.uv = [Vector(v.x, v.y) for v in uv.v]
|
|
def unfoldAll(feedback=None):
|
|
objects = Blender.Object.Get()
|
|
for object in objects:
|
|
if(object.getType()=='Mesh' and not(object.getName().endswith("_net")) and len(object.getData(False, True).faces)>1):
|
|
net = Net.createNet(object, feedback)
|
|
net.searchForUnfolding()
|
|
svg = SVGExporter(net, object.getName()+".svg")
|
|
svg.export()
|
|
unfoldAll = staticmethod(unfoldAll)
|
|
def searchForUnfolding(self, limit=-1):
|
|
overlaps = 1
|
|
attempts = 0
|
|
while(overlaps > 0 or attempts<limit):
|
|
self.unfold()
|
|
overlaps = self.report()
|
|
attempts+=1
|
|
return attempts
|
|
def unfoldSelected(feedback=None, netName=None):
|
|
return Net.createNet(Blender.Object.GetSelected()[0], feedback, netName)
|
|
unfoldSelected = staticmethod(unfoldSelected)
|
|
def clone(self, object=None):
|
|
if(object==None):
|
|
object = self.object
|
|
net = Net.createNet(object, self.feedback)
|
|
net.avoidsOverlaps = net.avoidsOverlaps
|
|
return net
|
|
def createNet(ob, feedback=None, netName=None):
|
|
mesh = ob.getData(mesh=1)
|
|
netObject = None
|
|
if(netName==None):
|
|
netName = ob.name[0:16]+"_net"
|
|
try:
|
|
netObject = Blender.Object.Get(netName)
|
|
netMesh = netObject.getData(False, True)
|
|
if(netMesh!=None):
|
|
netMesh.verts = None # clear the mesh
|
|
else:
|
|
netObject = Blender.Object.New("Mesh", netName)
|
|
except:
|
|
if(netObject==None):
|
|
netObject = Blender.Object.New("Mesh", netName)
|
|
netMesh = netObject.getData(False, True) # True means "as a Mesh not an NMesh"
|
|
try:
|
|
Blender.Scene.GetCurrent().objects.link(netObject)
|
|
except:
|
|
pass
|
|
try:
|
|
netMesh.materials = mesh.materials
|
|
netMesh.vertexColors = True
|
|
except:
|
|
print "Problem setting materials here"
|
|
net = Net(mesh, netMesh)
|
|
if(mesh.faceUV and mesh.activeFace>=0 and (mesh.faces[mesh.activeFace].flag & Mesh.FaceFlags.SELECT)):
|
|
net.firstFaceIndex = mesh.activeFace
|
|
net.object = ob
|
|
net.feedback = feedback
|
|
return net
|
|
createNet = staticmethod(createNet)
|
|
def importNet(filename):
|
|
netName = filename.rstrip(".svg").replace("\\","/")
|
|
netName = netName[netName.rfind("/")+1:]
|
|
try:
|
|
netObject = Blender.Object.Get(netName)
|
|
except:
|
|
netObject = Blender.Object.New("Mesh", netName)
|
|
netObject.getData(mesh=1).name = netName
|
|
try:
|
|
Blender.Scene.GetCurrent().objects.link(netObject)
|
|
except:
|
|
pass
|
|
net = Net(None, netObject.getData(mesh=1))
|
|
handler = NetHandler(net)
|
|
xml.sax.parse(filename, handler)
|
|
Window.Redraw(Window.Types.VIEW3D)
|
|
return net
|
|
importNet = staticmethod(importNet)
|
|
def getSourceMesh(self):
|
|
return self.src
|
|
|
|
# determines the order in which to visit faces according to a local measure
|
|
class EdgeIterator:
|
|
def __init__(self, branch, otherConstructor=None):
|
|
self.branch = branch
|
|
self.bface = branch.getFace()
|
|
self.edge = branch.getFold().getEdge()
|
|
self.net = branch.getNet()
|
|
self.n = len(self.bface)
|
|
self.edges = []
|
|
self.i = 0
|
|
self.gooodness = 0
|
|
self.createEdges()
|
|
self.computeGoodness()
|
|
if(otherConstructor==None):
|
|
self.sequenceEdges()
|
|
def createEdges(self):
|
|
edge = None
|
|
e = Edge.edgesOfBlenderFace(self.net.getSourceMesh(), self.bface)
|
|
for edge in e:
|
|
if not(edge.isBlenderSeam() and edge!=self.edge):
|
|
self.edges.append(edge)
|
|
def sequenceEdges(self):
|
|
pass
|
|
def next(self):
|
|
edge = self.edges[self.i]
|
|
self.i+=1
|
|
return edge
|
|
def size(self):
|
|
return len(self.edges)
|
|
def reset(self):
|
|
self.i = 0
|
|
def hasNext(self):
|
|
return (self.i<len(self.edges))
|
|
def goodness(self):
|
|
return self.gooodness
|
|
def computeGoodness(self):
|
|
self.gooodness = 0
|
|
def rotate(self):
|
|
self.edges.append(self.edges.pop(0))
|
|
|
|
class RandomEdgeIterator(EdgeIterator):
|
|
def sequenceEdges(self):
|
|
random.seed()
|
|
random.shuffle(self.edges)
|
|
def goodness(self):
|
|
return random.randint(0, self.net.srcSize())
|
|
|
|
|
|
class Largest(EdgeIterator):
|
|
def sequenceEdges(self):
|
|
for e in self.edges:
|
|
f = self.net.facesAndEdges.findAdjacentFace(self.bface, e)
|
|
if(f!=None):
|
|
e.setGoodness(f.area)
|
|
self.edges.sort(lambda e1, e2: -e1.compare(e2))
|
|
def computeGoodness(self):
|
|
self.gooodness = self.bface.area
|
|
|
|
|
|
class Brightest(EdgeIterator):
|
|
def sequenceEdges(self):
|
|
for edge in self.edges:
|
|
f = self.net.facesAndEdges.findAdjacentFace(self.bface, edge)
|
|
if(f!=None):
|
|
b = 0
|
|
if self.net.src.vertexColors:
|
|
for c in f.col:
|
|
b+=(c.g+c.r+c.b)
|
|
rc = float(random.randint(0, self.net.srcSize())) / float(self.net.srcSize()) / 100.0
|
|
b+=rc
|
|
edge.setGoodness(b)
|
|
self.edges.sort(lambda e1, e2: e1.compare(e2))
|
|
def computeGoodness(self):
|
|
g = 0
|
|
if self.net.src.vertexColors:
|
|
for c in self.bface.col:
|
|
g+=(c.g+c.r+c.b)
|
|
self.gooodness = g
|
|
|
|
class OddEven(EdgeIterator):
|
|
i = True
|
|
def sequenceEdges(self):
|
|
OddEven.i = not(OddEven.i)
|
|
if(OddEven.i):
|
|
self.edges.reverse()
|
|
|
|
class Curvature(EdgeIterator):
|
|
def sequenceEdges(self):
|
|
p1 = Poly.fromBlenderFace(self.bface)
|
|
gg = 0.0
|
|
for edge in self.edges:
|
|
f = self.net.facesAndEdges.findAdjacentFace(self.bface, edge)
|
|
if(f!=None):
|
|
p2 = Poly.fromBlenderFace(f)
|
|
fold = Fold(None, p1, p2, edge)
|
|
fold.srcFace = f
|
|
b = Tree(self.net, self.branch, fold, self)
|
|
c = Curvature(b, False)
|
|
g = c.goodness()
|
|
gg+=g
|
|
edge.setGoodness(g)
|
|
self.edges.sort(lambda e1, e2: e1.compare(e2))
|
|
tg = (self.gooodness + gg)
|
|
rc = float(random.randint(0, self.net.srcSize())) / float(self.net.srcSize()) / 100.0
|
|
if(tg!=0.0):
|
|
self.gooodness = self.gooodness + rc / tg
|
|
def computeGoodness(self):
|
|
g = 0
|
|
for edge in self.edges:
|
|
f = self.net.facesAndEdges.findAdjacentFace(self.bface, edge)
|
|
if(f!=None):
|
|
p1 = Poly.fromBlenderFace(self.bface)
|
|
p2 = Poly.fromBlenderFace(f)
|
|
f = Fold(None, p1, p2, edge)
|
|
g += f.dihedralAngle()
|
|
self.gooodness = g
|
|
|
|
|
|
class Edge:
|
|
def __init__(self, v1=None, v2=None, mEdge=None, i=-1):
|
|
self.idx = i
|
|
if v1 and v2:
|
|
self.v1 = v1.copy()
|
|
self.v2 = v2.copy()
|
|
else:
|
|
self.v1 = mEdge.v1.co.copy()
|
|
self.v2 = mEdge.v2.co.copy()
|
|
self.v1n = -self.v1
|
|
self.vector = self.v1-self.v2
|
|
self.vector.resize3D()
|
|
self.vector.normalize()
|
|
self.bmEdge = mEdge
|
|
self.gooodness = 0.0
|
|
def fromBlenderFace(mesh, bface, i):
|
|
if(i>len(bface)-1):
|
|
return None
|
|
if(i==len(bface)-1):
|
|
j = 0
|
|
else:
|
|
j = i+1
|
|
edge = Edge( bface.v[i].co.copy(), bface.v[j].co.copy() )
|
|
edge.bEdge = mesh.findEdge(bface.v[i], bface.v[j])
|
|
edge.idx = i
|
|
return edge
|
|
fromBlenderFace=staticmethod(fromBlenderFace)
|
|
def edgesOfBlenderFace(mesh, bmFace):
|
|
edges = [mesh.edges[mesh.findEdges(edge[0], edge[1])] for edge in bmFace.edge_keys]
|
|
v = bmFace.verts
|
|
e = []
|
|
vi = v[0]
|
|
i=0
|
|
for j in xrange(1, len(bmFace)+1):
|
|
vj = v[j%len(bmFace)]
|
|
for ee in edges:
|
|
if((ee.v1.index==vi.index and ee.v2.index==vj.index) or (ee.v2.index==vi.index and ee.v1.index==vj.index)):
|
|
e.append(Edge(vi.co, vj.co, ee, i))
|
|
i+=1
|
|
vi = vj
|
|
return e
|
|
edgesOfBlenderFace=staticmethod(edgesOfBlenderFace)
|
|
def isBlenderSeam(self):
|
|
return (self.bmEdge.flag & Mesh.EdgeFlags.SEAM)
|
|
def isInFGon(self):
|
|
return (self.bmEdge.flag & Mesh.EdgeFlags.FGON)
|
|
def mapTo(self, poly):
|
|
if(self.idx==len(poly.v)-1):
|
|
j = 0
|
|
else:
|
|
j = self.idx+1
|
|
return Edge(poly.v[self.idx], poly.v[j])
|
|
def isDegenerate(self):
|
|
return self.vector.length==0
|
|
def vertices(s):
|
|
return [ [s.v1.x, s.v1.y, s.v1.z], [s.v2.x, s.v2.y,s.v2.z] ]
|
|
def key(self):
|
|
return self.bmEdge.key
|
|
def goodness(self):
|
|
return self.gooodness
|
|
def setGoodness(self, g):
|
|
self.gooodness = g
|
|
def compare(self, other):
|
|
if(self.goodness() > other.goodness()):
|
|
return +1
|
|
else:
|
|
return -1
|
|
|
|
class Poly:
|
|
ids = -1
|
|
def __init__(self):
|
|
Poly.ids+=1
|
|
self.v = []
|
|
self.id = Poly.ids
|
|
self.boundz = None
|
|
def getID(self):
|
|
return self.id
|
|
def normal(self):
|
|
a =self.v[0]
|
|
b=self.v[1]
|
|
c=self.v[2]
|
|
p = b-a
|
|
p.resize3D()
|
|
q = a-c
|
|
q.resize3D()
|
|
return CrossVecs(p,q)
|
|
def isBad(self):
|
|
badness = 0
|
|
for vv in self.v:
|
|
if(vv.x!=vv.x or vv.y!=vv.y or vv.z!=vv.z): # Nan check
|
|
badness+=1
|
|
return (badness>0)
|
|
def midpoint(self):
|
|
x=y=z = 0.0
|
|
n = 0
|
|
for vv in self.v:
|
|
x+=vv.x
|
|
y+=vv.y
|
|
z+=vv.z
|
|
n+=1
|
|
return [ x/n, y/n, z/n ]
|
|
def centerAtOrigin(self):
|
|
mp = self.midpoint()
|
|
mp = -mp
|
|
toOrigin = TranslationMatrix(mp)
|
|
self.v = [(vv * toOrigin) for vv in self.v]
|
|
def move(self, tv):
|
|
mv = TranslationMatrix(tv)
|
|
self.v = [(vv * mv) for vv in self.v]
|
|
def scale(self, s):
|
|
mp = Vector(self.midpoint())
|
|
fromOrigin = TranslationMatrix(mp)
|
|
mp = -mp
|
|
toOrigin = TranslationMatrix(mp)
|
|
sm = ScaleMatrix(s, 4)
|
|
# Todo, the 3 lines below in 1 LC
|
|
self.v = [(vv * toOrigin) for vv in self.v]
|
|
self.v = [(sm * vv) for vv in self.v]
|
|
self.v = [(vv * fromOrigin) for vv in self.v]
|
|
def nPoints(self):
|
|
return len(self.v)
|
|
def size(self):
|
|
return len(self.v)
|
|
def rotated(self, axis, angle):
|
|
p = self.clone()
|
|
p.rotate(axis, angle)
|
|
return p
|
|
def rotate(self, axis, angle):
|
|
rotation = RotationMatrix(angle, 4, "r", axis.vector)
|
|
toOrigin = TranslationMatrix(axis.v1n)
|
|
fromOrigin = TranslationMatrix(axis.v1)
|
|
# Todo, the 3 lines below in 1 LC
|
|
self.v = [(vv * toOrigin) for vv in self.v]
|
|
self.v = [(rotation * vv) for vv in self.v]
|
|
self.v = [(vv * fromOrigin) for vv in self.v]
|
|
def moveAlong(self, vector, distance):
|
|
t = TranslationMatrix(vector)
|
|
s = ScaleMatrix(distance, 4)
|
|
ts = t*s
|
|
self.v = [(vv * ts) for vv in self.v]
|
|
def bounds(self):
|
|
if(self.boundz == None):
|
|
vv = [vv for vv in self.v]
|
|
vv.sort(key=lambda v: v.x)
|
|
minx = vv[0].x
|
|
maxx = vv[len(vv)-1].x
|
|
vv.sort(key=lambda v: v.y)
|
|
miny = vv[0].y
|
|
maxy = vv[len(vv)-1].y
|
|
self.boundz = [Vector(minx, miny, 0), Vector(maxx, maxy, 0)]
|
|
return self.boundz
|
|
def fromBlenderFace(bface):
|
|
p = Poly()
|
|
for vv in bface.v:
|
|
vec = Vector([vv.co[0], vv.co[1], vv.co[2] , 1.0])
|
|
p.v.append(vec)
|
|
return p
|
|
fromBlenderFace = staticmethod(fromBlenderFace)
|
|
def fromList(list):
|
|
p = Poly()
|
|
for vv in list:
|
|
vec = Vector( [vvv for vvv in vv] )
|
|
vec.resize4D()
|
|
p.v.append(vec)
|
|
return p
|
|
fromList = staticmethod(fromList)
|
|
def fromVectors(vectors):
|
|
p = Poly()
|
|
p.v.extend([v.copy().resize4D() for v in vectors])
|
|
return p
|
|
fromVectors = staticmethod(fromVectors)
|
|
def clone(self):
|
|
p = Poly()
|
|
p.v.extend(self.v)
|
|
return p
|
|
def hasVertex(self, ttv):
|
|
v = Mathutils.Vector(ttv)
|
|
v.normalize()
|
|
for tv in self.v:
|
|
vv = Mathutils.Vector(tv)
|
|
vv.normalize()
|
|
t = 0.00001
|
|
if abs(vv.x-v.x)<t and abs(vv.y-v.y)<t:
|
|
return True
|
|
return False
|
|
def overlays(self, poly):
|
|
if len(poly.v)!=len(self.v):
|
|
return False
|
|
c = 0
|
|
for point in poly.v:
|
|
if self.hasVertex(point):
|
|
c+=1
|
|
return c==len(self.v)
|
|
def sharesVertexWith(self, poly):
|
|
for point in poly.v:
|
|
if(self.hasVertex(point)):
|
|
return True
|
|
return False
|
|
def containsAnyOf(self, poly):
|
|
for point in poly.v:
|
|
if(not(self.hasVertex(point))):
|
|
if self.contains(point):
|
|
return True
|
|
return False
|
|
def toString(self):
|
|
return self.v
|
|
# This is the BEST algorithm for point-in-polygon detection.
|
|
# It's by W. Randolph Franklin. It's also very beautiful (looks even better in C).
|
|
# All the others are shite; they give false positives.
|
|
# returns 1 for inside, 1 or 0 for edges
|
|
def contains(self, tp):
|
|
c = 0
|
|
j = len(self.v)-1
|
|
for i in xrange(len(self.v)):
|
|
if(i>0): j=i-1
|
|
cv = self.v[i]
|
|
nv = self.v[j]
|
|
if ((((cv.y<=tp.y) and (tp.y<nv.y)) or ((nv.y<=tp.y) and (tp.y<cv.y))) and (tp.x < (nv.x - cv.x) * (tp.y - cv.y) / (nv.y - cv.y) + cv.x)):
|
|
c = not(c)
|
|
return (c == 1)
|
|
|
|
class SVGExporter:
|
|
def __init__(self, net, filename):
|
|
self.net = net
|
|
print self.net.des.name
|
|
self.object = self.net.object
|
|
print "Exporting ", self.object
|
|
self.filename = filename
|
|
self.file = None
|
|
self.e = None
|
|
self.width = 1024
|
|
self.height = 768
|
|
def start(self):
|
|
print "Exporting SVG to ", self.filename
|
|
self.file = open(self.filename, 'w')
|
|
self.e = xml.sax.saxutils.XMLGenerator(self.file, "UTF-8")
|
|
atts = {}
|
|
atts["width"] = "100%"
|
|
atts["height"] = "100%"
|
|
atts["viewBox"] = str(self.vxmin)+" "+str(self.vymin)+" "+str(self.vxmax-self.vxmin)+" "+str(self.vymax-self.vymin)
|
|
atts["xmlns:nets"] = "http://celeriac.net/unfolder/rdf#"
|
|
atts["xmlns:xlink"] = "http://www.w3.org/1999/xlink"
|
|
atts["xmlns"] ="http://www.w3.org/2000/svg"
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startDocument()
|
|
self.e.startElement("svg", a)
|
|
self.e.startElement("defs", xml.sax.xmlreader.AttributesImpl({}))
|
|
atts = {}
|
|
atts["type"]="text/css"
|
|
self.e.startElement("style", atts)
|
|
# can't find a proper way to do this
|
|
self.file.write("<![CDATA[")
|
|
self.file.write("polygon.poly{fill:white;stroke:black;stroke-width: 0.001}")
|
|
self.file.write("g#foldLines line.valley{stroke:white;stroke-width:0.01;stroke-dasharray:0.02,0.01,0.02,0.05}")
|
|
self.file.write("g#foldLines line.mountain{stroke:white;stroke-width:0.01;stroke-dasharray:0.02,0.04}")
|
|
self.file.write("]]>")
|
|
self.e.endElement("style")
|
|
self.e.endElement("defs")
|
|
#self.addClipPath()
|
|
self.addMeta()
|
|
def addMeta(self):
|
|
self.e.startElement("metadata", xml.sax.xmlreader.AttributesImpl({}))
|
|
self.e.startElement("nets:net", xml.sax.xmlreader.AttributesImpl({}))
|
|
for i in xrange(1, len(self.net.folds)):
|
|
fold = self.net.folds[i]
|
|
# AttributesNSImpl - documentation is rubbish. using this hack.
|
|
atts = {}
|
|
atts["nets:id"] = "fold"+str(fold.getID())
|
|
if(fold.parent!=None):
|
|
atts["nets:parent"] = "fold"+str(fold.parent.getID())
|
|
else:
|
|
atts["nets:parent"] = "null"
|
|
atts["nets:da"] = str(fold.dihedralAngle())
|
|
if(fold.parent!=None):
|
|
atts["nets:ofPoly"] = "poly"+str(fold.parent.foldingPoly.getID())
|
|
else:
|
|
atts["nets:ofPoly"] = ""
|
|
atts["nets:toPoly"] = "poly"+str(fold.foldingPoly.getID())
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("nets:fold", a)
|
|
self.e.endElement("nets:fold")
|
|
self.e.endElement("nets:net")
|
|
self.e.endElement("metadata")
|
|
def end(self):
|
|
self.e.endElement("svg")
|
|
self.e.endDocument()
|
|
print "grown."
|
|
def export(self):
|
|
self.net.unfoldTo(1)
|
|
bb = self.object.getBoundBox()
|
|
self.vxmin = bb[0][0]
|
|
self.vymin = bb[0][1]
|
|
self.vxmax = bb[7][0]
|
|
self.vymax = bb[7][1]
|
|
self.start()
|
|
atts = {}
|
|
atts["id"] = self.object.getName()
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("g", a)
|
|
#self.addUVImage()
|
|
self.addPolys()
|
|
self.addFoldLines()
|
|
#self.addCutLines()
|
|
self.e.endElement("g")
|
|
self.end()
|
|
def addClipPath(self):
|
|
atts = {}
|
|
atts["id"] = "netClip"
|
|
atts["clipPathUnits"] = "userSpaceOnUse"
|
|
atts["x"] = str(self.vxmin)
|
|
atts["y"] = str(self.vymin)
|
|
atts["width"] = "100%"
|
|
atts["height"] = "100%"
|
|
self.e.startElement("clipPath", atts)
|
|
self.addPolys()
|
|
self.e.endElement("clipPath")
|
|
def addUVImage(self):
|
|
image = Blender.Image.GetCurrent()
|
|
if image==None:
|
|
return
|
|
ifn = image.getFilename()
|
|
#ifn = self.filename.replace(".svg", ".jpg")
|
|
#image.setFilename(ifn)
|
|
#ifn = ifn[ifn.rfind("/")+1:]
|
|
#image.save()
|
|
atts = {}
|
|
atts["clip-path"] = "url(#netClip)"
|
|
atts["xlink:href"] = ifn
|
|
self.e.startElement("image", atts)
|
|
self.e.endElement("image")
|
|
def addPolys(self):
|
|
atts = {}
|
|
atts["id"] = "polys"
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("g", a)
|
|
for i in xrange(len(self.net.folds)):
|
|
self.addPoly(self.net.folds[i])
|
|
self.e.endElement("g")
|
|
def addFoldLines(self):
|
|
atts = {}
|
|
atts["id"] = "foldLines"
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("g", a)
|
|
for i in xrange( 1, len(self.net.folds)):
|
|
self.addFoldLine(self.net.folds[i])
|
|
self.e.endElement("g")
|
|
def addFoldLine(self, fold):
|
|
edge = fold.edge.mapTo(fold.parent.foldingPoly)
|
|
if fold.dihedralAngle()>0:
|
|
foldType="valley"
|
|
else:
|
|
foldType="mountain"
|
|
atts={}
|
|
atts["x1"] = str(edge.v1.x)
|
|
atts["y1"] = str(edge.v1.y)
|
|
atts["x2"] = str(edge.v2.x)
|
|
atts["y2"] = str(edge.v2.y)
|
|
atts["id"] = "fold"+str(fold.getID())
|
|
atts["class"] = foldType
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("line", a)
|
|
self.e.endElement("line")
|
|
def addCutLines(self):
|
|
atts = {}
|
|
atts["id"] = "cutLines"
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("g", a)
|
|
for i in xrange( 1, len(self.net.cuts)):
|
|
self.addCutLine(self.net.cuts[i])
|
|
self.e.endElement("g")
|
|
def addCutLine(self, cut):
|
|
edge = cut.edge.mapTo(cut.parent.foldingPoly)
|
|
if cut.dihedralAngle()>0:
|
|
foldType="valley"
|
|
else:
|
|
foldType="mountain"
|
|
atts={}
|
|
atts["x1"] = str(edge.v1.x)
|
|
atts["y1"] = str(edge.v1.y)
|
|
atts["x2"] = str(edge.v2.x)
|
|
atts["y2"] = str(edge.v2.y)
|
|
atts["id"] = "cut"+str(cut.getID())
|
|
atts["class"] = foldType
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("line", a)
|
|
self.e.endElement("line")
|
|
def addPoly(self, fold):
|
|
face = fold.foldingPoly
|
|
atts = {}
|
|
if fold.desFace.col:
|
|
col = fold.desFace.col[0]
|
|
rgb = "rgb("+str(col.r)+","+str(col.g)+","+str(col.b)+")"
|
|
atts["fill"] = rgb
|
|
atts["class"] = "poly"
|
|
atts["id"] = "poly"+str(face.getID())
|
|
points = ""
|
|
first = True
|
|
for vv in face.v:
|
|
if(not(first)):
|
|
points+=','
|
|
first = False
|
|
points+=str(vv[0])
|
|
points+=' '
|
|
points+=str(vv[1])
|
|
atts["points"] = points
|
|
a = xml.sax.xmlreader.AttributesImpl(atts)
|
|
self.e.startElement("polygon", a)
|
|
self.e.endElement("polygon")
|
|
def fileSelected(filename):
|
|
try:
|
|
net = Registry.GetKey('unfolder')['net']
|
|
exporter = SVGExporter(net, filename)
|
|
exporter.export()
|
|
except:
|
|
print "Problem exporting SVG"
|
|
traceback.print_exc(file=sys.stdout)
|
|
fileSelected = staticmethod(fileSelected)
|
|
|
|
|
|
class NetHandler(xml.sax.handler.ContentHandler):
|
|
def __init__(self, net):
|
|
self.net = net
|
|
self.first = (41==41)
|
|
self.currentElement = None
|
|
self.chars = None
|
|
self.currentAction = None
|
|
self.foldsPending = {}
|
|
self.polys = {}
|
|
self.actions = {}
|
|
self.actions["nets:fold"] = self.foldInfo
|
|
self.actions["line"] = self.cutOrFold
|
|
self.actions["polygon"] = self.createPoly
|
|
def setDocumentLocator(self, locator):
|
|
pass
|
|
def startDocument(self):
|
|
pass
|
|
def endDocument(self):
|
|
for fold in self.foldsPending.values():
|
|
face = self.net.addFace(fold.unfoldedFace())
|
|
fold.desFace = face
|
|
self.net.folds.append(fold)
|
|
self.net.addFace(self.first)
|
|
self.foldsPending = None
|
|
self.polys = None
|
|
def startPrefixMapping(self, prefix, uri):
|
|
pass
|
|
def endPrefixMapping(self, prefix):
|
|
pass
|
|
def startElement(self, name, attributes):
|
|
self.currentAction = None
|
|
try:
|
|
self.currentAction = self.actions[name]
|
|
except:
|
|
pass
|
|
if(self.currentAction!=None):
|
|
self.currentAction(attributes)
|
|
def endElement(self, name):
|
|
pass
|
|
def startElementNS(self, name, qname, attrs):
|
|
self.currentAction = self.actions[name]
|
|
if(self.currentAction!=None):
|
|
self.currentAction(attributes)
|
|
def endElementNS(self, name, qname):
|
|
pass
|
|
def characters(self, content):
|
|
pass
|
|
def ignorableWhitespace(self):
|
|
pass
|
|
def processingInstruction(self, target, data):
|
|
pass
|
|
def skippedEntity(self, name):
|
|
pass
|
|
def foldInfo(self, atts):
|
|
self.foldsPending[atts["nets:id"]] = atts
|
|
def createPoly(self, atts):
|
|
xy = re.split('[, ]' , atts["points"])
|
|
vectors = []
|
|
for i in xrange(0, len(xy)-1, 2):
|
|
v = Vector([float(xy[i]), float(xy[i+1]), 0.0])
|
|
vectors.append(v)
|
|
poly = Poly.fromVectors(vectors)
|
|
if(self.first==True):
|
|
self.first = poly
|
|
self.polys[atts["id"]] = poly
|
|
def cutOrFold(self, atts):
|
|
fid = atts["id"]
|
|
try:
|
|
fi = self.foldsPending[fid]
|
|
except:
|
|
pass
|
|
p1 = Vector([float(atts["x1"]), float(atts["y1"]), 0.0])
|
|
p2 = Vector([float(atts["x2"]), float(atts["y2"]), 0.0])
|
|
edge = Edge(p1, p2)
|
|
parent = None
|
|
ofPoly = None
|
|
toPoly = None
|
|
try:
|
|
parent = self.foldsPending[fi["nets:parent"]]
|
|
except:
|
|
pass
|
|
try:
|
|
ofPoly = self.polys[fi["nets:ofPoly"]]
|
|
except:
|
|
pass
|
|
try:
|
|
toPoly = self.polys[fi["nets:toPoly"]]
|
|
except:
|
|
pass
|
|
fold = Fold(parent, ofPoly , toPoly, edge, float(fi["nets:da"]))
|
|
self.foldsPending[fid] = fold
|
|
def fileSelected(filename):
|
|
try:
|
|
net = Net.importNet(filename)
|
|
try:
|
|
Registry.GetKey('unfolder')['net'] = net
|
|
except:
|
|
Registry.SetKey('unfolder', {})
|
|
Registry.GetKey('unfolder')['net'] = net
|
|
Registry.GetKey('unfolder')['lastpath'] = filename
|
|
except:
|
|
print "Problem importing SVG"
|
|
traceback.print_exc(file=sys.stdout)
|
|
fileSelected = staticmethod(fileSelected)
|
|
|
|
|
|
class GUI:
|
|
def __init__(self):
|
|
self.overlaps = Draw.Create(0)
|
|
self.ani = Draw.Create(0)
|
|
self.selectedFaces =0
|
|
self.search = Draw.Create(0)
|
|
self.diffuse = True
|
|
self.ancestors = Draw.Create(0)
|
|
self.noise = Draw.Create(0.0)
|
|
self.shape = Draw.Create(0)
|
|
self.nOverlaps = 1==2
|
|
self.iterators = [RandomEdgeIterator,Brightest,Curvature,EdgeIterator,OddEven,Largest]
|
|
self.iterator = RandomEdgeIterator
|
|
self.overlapsText = "*"
|
|
self.message = " "
|
|
def makePopupGUI(self):
|
|
useRandom = Draw.Create(0)
|
|
pub = []
|
|
pub.append(("Search", self.search, "Search for non-overlapping net (maybe forever)"))
|
|
pub.append(("Random", useRandom, "Random style net"))
|
|
ok = True
|
|
while ok:
|
|
ok = Blender.Draw.PupBlock("Unfold", pub)
|
|
if ok:
|
|
if useRandom.val:
|
|
self.iterator = RandomEdgeIterator
|
|
else:
|
|
self.iterator = Curvature
|
|
self.unfold()
|
|
def makeStandardGUI(self):
|
|
Draw.Register(self.draw, self.keyOrMouseEvent, self.buttonEvent)
|
|
def installScriptLink(self):
|
|
print "Adding script link for animation"
|
|
s = Blender.Scene.GetCurrent().getScriptLinks("FrameChanged")
|
|
if(s!=None and s.count("frameChanged.py")>0):
|
|
return
|
|
try:
|
|
script = Blender.Text.Get("frameChanged.py")
|
|
except:
|
|
script = Blender.Text.New("frameChanged.py")
|
|
script.write("import Blender\n")
|
|
script.write("import mesh_unfolder as Unfolder\n")
|
|
script.write("u = Blender.Registry.GetKey('unfolder')\n")
|
|
script.write("if u!=None:\n")
|
|
script.write("\tn = u['net']\n")
|
|
script.write("\tif(n!=None and n.animates):\n")
|
|
script.write("\t\tn.unfoldToCurrentFrame()\n")
|
|
Blender.Scene.GetCurrent().addScriptLink("frameChanged.py", "FrameChanged")
|
|
def unfold(self):
|
|
anc = self.ancestors.val
|
|
n = 0.0
|
|
s = True
|
|
self.nOverlaps = 0
|
|
searchLimit = 10
|
|
search = 1
|
|
Draw.Redraw(1)
|
|
net = None
|
|
name = None
|
|
try:
|
|
self.say("Unfolding...")
|
|
Draw.Redraw(1)
|
|
while(s):# and search < searchLimit):
|
|
if(net!=None):
|
|
name = net.des.name
|
|
net = Net.unfoldSelected(self, name)
|
|
net.setAvoidsOverlaps(not(self.overlaps.val))
|
|
print
|
|
print "Unfolding selected object"
|
|
net.edgeIteratorClass = self.iterator
|
|
print "Using ", net.edgeIteratorClass
|
|
net.animates = self.ani.val
|
|
self.diffuse = (self.ancestors.val==0)
|
|
net.diffuse = self.diffuse
|
|
net.generations = self.ancestors.val
|
|
net.noise = self.noise.val
|
|
print "even:", net.diffuse, " depth:", net.generations
|
|
net.unfold()
|
|
n = net.report()
|
|
t = "."
|
|
if(n<1.0):
|
|
t = "Overlaps>="+str(n)
|
|
else:
|
|
t = "A complete net."
|
|
self.nOverlaps = (n>=1)
|
|
if(self.nOverlaps):
|
|
self.say(self.message+" - unfolding failed - try again ")
|
|
elif(not(self.overlaps.val)):
|
|
self.say("Success. Complete net - no overlaps ")
|
|
else:
|
|
self.say("Unfolding complete")
|
|
self.ancestors.val = anc
|
|
s = (self.search.val and n>=1.0)
|
|
dict = Registry.GetKey('unfolder')
|
|
if(not(dict)):
|
|
dict = {}
|
|
dict['net'] = net
|
|
Registry.SetKey('unfolder', dict)
|
|
if(s):
|
|
net = net.clone()
|
|
search += 1
|
|
except(IndexError):
|
|
self.say("Please select an object to unfold")
|
|
except:
|
|
self.say("Problem unfolding selected object - see console for details")
|
|
print "Problem unfolding selected object:"
|
|
print sys.exc_info()[1]
|
|
traceback.print_exc(file=sys.stdout)
|
|
if(self.ani):
|
|
if Registry.GetKey('unfolder')==None:
|
|
print "no net!"
|
|
return
|
|
Registry.GetKey('unfolder')['net'].sortOutIPOSource()
|
|
self.installScriptLink()
|
|
Draw.Redraw(1)
|
|
def keyOrMouseEvent(self, evt, val):
|
|
if (evt == Draw.ESCKEY and not val):
|
|
Draw.Exit()
|
|
def buttonEvent(self, evt):
|
|
if (evt == 1):
|
|
self.unfold()
|
|
if (evt == 5):
|
|
try:
|
|
Registry.GetKey('unfolder')['net'].setAvoidsOverlaps(self.overlaps.val)
|
|
except:
|
|
pass
|
|
if (evt == 2):
|
|
print "Trying to set IPO curve"
|
|
try:
|
|
s = Blender.Object.GetSelected()
|
|
if(s!=None):
|
|
Registry.GetKey('unfolder')['net'].setIPOSource( s[0] )
|
|
print "Set IPO curve"
|
|
else:
|
|
print "Please select an object to use the IPO of"
|
|
except:
|
|
print "Problem setting IPO source"
|
|
Draw.Redraw(1)
|
|
if (evt == 6):
|
|
Draw.Exit()
|
|
if (evt == 7):
|
|
try:
|
|
if (Registry.GetKey('unfolder')['net']!=None):
|
|
Registry.GetKey('unfolder')['net'].animates = self.ani.val
|
|
if(self.ani):
|
|
Registry.GetKey('unfolder')['net'].sortOutIPOSource()
|
|
self.installScriptLink()
|
|
except:
|
|
print sys.exc_info()[1]
|
|
traceback.print_exc(file=sys.stdout)
|
|
Draw.Redraw(1)
|
|
if (evt == 19):
|
|
pass
|
|
if (evt == 87):
|
|
try:
|
|
if (Registry.GetKey('unfolder')['net']!=None):
|
|
Registry.GetKey('unfolder')['net'].assignUVs()
|
|
self.say("Assigned UVs")
|
|
except:
|
|
print sys.exc_info()[1]
|
|
traceback.print_exc(file=sys.stdout)
|
|
Draw.Redraw(1)
|
|
if(evt==91):
|
|
if( testOverlap() == True):
|
|
self.nOverlaps = 1
|
|
else:
|
|
self.nOverlaps = 0
|
|
Draw.Redraw(1)
|
|
if(evt==714):
|
|
Net.unfoldAll(self)
|
|
Draw.Redraw(1)
|
|
if(evt==713):
|
|
self.iterator = self.iterators[self.shape.val]
|
|
Draw.Redraw(1)
|
|
if(evt==92):
|
|
if( testContains() == True):
|
|
self.nOverlaps = 1
|
|
else:
|
|
self.nOverlaps = 0
|
|
Draw.Redraw(1)
|
|
if(evt==104):
|
|
try:
|
|
filename = "net.svg"
|
|
s = Blender.Object.GetSelected()
|
|
if(s!=None and len(s)>0):
|
|
filename = s[0].getName()+".svg"
|
|
else:
|
|
if (Registry.GetKey('unfolder')['net']!=None):
|
|
filename = Registry.GetKey('unfolder')['net'].des.name
|
|
if(filename==None):
|
|
filename="net.svg"
|
|
else:
|
|
filename=filename+".svg"
|
|
Window.FileSelector(SVGExporter.fileSelected, "Select filename", filename)
|
|
except:
|
|
print "Problem exporting SVG"
|
|
traceback.print_exc(file=sys.stdout)
|
|
if(evt==107):
|
|
try:
|
|
Window.FileSelector(NetHandler.fileSelected, "Select file")
|
|
except:
|
|
print "Problem importing SVG"
|
|
traceback.print_exc(file=sys.stdout)
|
|
def say(self, m):
|
|
self.message = m
|
|
Draw.Redraw(1)
|
|
Window.Redraw(Window.Types.SCRIPT)
|
|
def draw(self):
|
|
cw = 64
|
|
ch = 16
|
|
l = FlowLayout(32, cw, ch, 350, 64)
|
|
l.y = 70
|
|
self.search = Draw.Toggle("search", 19, l.nx(), l.ny(), l.cw, l.ch, self.search.val, "Search for non-overlapping mesh (potentially indefinitely)")
|
|
self.overlaps = Draw.Toggle("overlaps", 5, l.nx(), l.ny(), l.cw, l.ch, self.overlaps.val, "Allow overlaps / avoid overlaps - if off, will not place overlapping faces")
|
|
self.ani = Draw.Toggle("ani", 7, l.nx(), l.ny(), l.cw, l.ch, self.ani.val, "Animate net")
|
|
Draw.Button("uv", 87, l.nx(), l.ny(), l.cw, l.ch, "Assign net as UV to source mesh (overwriting existing UV)")
|
|
Draw.Button("Unfold", 1, l.nx(), l.ny(), l.cw, l.ch, "Unfold selected mesh to net")
|
|
Draw.Button("save", 104, l.nx(), l.ny(), l.cw, l.ch, "Save net as SVG")
|
|
Draw.Button("load", 107, l.nx(), l.ny(), l.cw, l.ch, "Load net from SVG")
|
|
# unfolding enthusiasts - try uncommenting this
|
|
self.ancestors = Draw.Number("depth", 654, l.nx(), l.ny(), cw, ch, self.ancestors.val, 0, 9999, "depth of branching 0=diffuse")
|
|
#self.noise = Draw.Number("noise", 631, l.nx(), l.ny(), cw, ch, self.noise.val, 0.0, 1.0, "noisyness of branching")
|
|
#Draw.Button("UnfoldAll", 714, l.nx(), l.ny(), l.cw, l.ch, "Unfold all meshes and save their nets")
|
|
options = "order %t|random %x0|brightest %x1|curvature %x2|winding %x3| 1010 %x4|largest %x5"
|
|
self.shape = Draw.Menu(options, 713, l.nx(), l.ny(), cw, ch, self.shape.val, "shape of net")
|
|
Draw.Button("exit", 6, l.nx(), l.ny(), l.cw, l.ch, "exit")
|
|
BGL.glClearColor(0.5, 0.5, 0.5, 1)
|
|
BGL.glColor3f(0.3,0.3,0.3)
|
|
l.newLine()
|
|
BGL.glRasterPos2i(32, 100)
|
|
Draw.Text(self.message)
|
|
|
|
class FlowLayout:
|
|
def __init__(self, margin, cw, ch, w, h):
|
|
self.x = margin-cw-4
|
|
self.y = margin
|
|
self.cw = cw
|
|
self.ch = ch
|
|
self.width = w
|
|
self.height = h
|
|
self.margin = margin
|
|
def nx(self):
|
|
self.x+=(self.cw+4)
|
|
if(self.x>self.width):
|
|
self.x = self.margin
|
|
self.y-=self.ch+4
|
|
return self.x
|
|
def ny(self):
|
|
return self.y
|
|
def newLine(self):
|
|
self.y-=self.ch+self.margin
|
|
self.x = self.margin
|
|
|
|
try:
|
|
sys.setrecursionlimit(10000)
|
|
gui = GUI()
|
|
gui.makeStandardGUI()
|
|
#gui.makePopupGUI()
|
|
except:
|
|
traceback.print_exc(file=sys.stdout)
|