path: root/release/scripts/skin.py

#!BPY

"""
Name: 'Bridge Faces/Edge-Loops'
Blender: 237
Group: 'Mesh'
Tooltip: 'Select 2 vert loops, then run this script.'
"""

__author__ = "Campbell Barton AKA Ideasman"
__url__ = ["http://members.iinet.net.au/~cpbarton/ideasman/", "blender", "elysiun"]
__version__ = "1.0 2004/04/25"

__bpydoc__ = """\
With this script vertex loops can be skinned: faces are created to connect the
selected loops of vertices.

Usage:

In mesh Edit mode select the vertices of the loops (closed paths / curves of
vertices: circles, for example) that should be skinned, then run this script.
A pop-up will provide further options, if the results of a method are not adequate try one of the others.
"""


# $Id$
#
# -------------------------------------------------------------------------- 
# Skin Selected edges 1.0 By Campbell Barton (AKA Ideasman)
# -------------------------------------------------------------------------- 
# ***** BEGIN GPL LICENSE BLOCK ***** 
# 
# This program is free software; you can redistribute it and/or 
# modify it under the terms of the GNU General Public License 
# as published by the Free Software Foundation; either version 2 
# of the License, or (at your option) any later version. 
# 
# This program is distributed in the hope that it will be useful, 
# but WITHOUT ANY WARRANTY; without even the implied warranty of 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
# GNU General Public License for more details. 
# 
# You should have received a copy of the GNU General Public License 
# along with this program; if not, write to the Free Software Foundation, 
# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
# 
# ***** END GPL LICENCE BLOCK ***** 
# -------------------------------------------------------------------------- 

# Made by Ideasman/Campbell 2005/06/15 - ideasman@linuxmail.org

import Blender
from Blender import *

BIG_NUM = 1<<30

global CULL_METHOD
CULL_METHOD = 0

class edge:
	def __init__(self, v1,v2):
		self.v1 = v1
		self.v2 = v2
		
		# uv1 uv2 vcol1 vcol2 # Add later
		self.length = (v1.co - v2.co).length
		
		self.removed = 0 # Have we been culled from the eloop
		self.match = None # The other edge were making a face with


class edgeLoop:
	def __init__(self, loop): # Vert loop
		# Use next and prev, nextDist, prevDist
		
		# Get Loops centre.
		self.centre = Mathutils.Vector()
		f = 1.0/len(loop)
		for v in loop:
			self.centre += v.co * f
		
		
		
		
		# Convert Vert loop to Edges.
		self.edges = []
		vIdx = 0
		while vIdx < len(loop):
			self.edges.append( edge(loop[vIdx-1], loop[vIdx]) )
			vIdx += 1
		
		# Assign linked list
		for eIdx in range(len(self.edges)-1):
			self.edges[eIdx].next = self.edges[eIdx+1]
			self.edges[eIdx].prev = self.edges[eIdx-1]
		# Now last
		self.edges[-1].next = self.edges[0]
		self.edges[-1].prev = self.edges[-2]
		
		
		
		# GENERATE AN AVERAGE NORMAL FOR THE WHOLE LOOP.
		self.normal = Mathutils.Vector()
		for e in self.edges:
			n = Mathutils.CrossVecs(self.centre-e.v1.co, self.centre-e.v2.co)
			# Do we realy need tot normalize?
			n.normalize()
			self.normal += n
		self.normal.normalize()
		
		
		# Generate a normal for each edge.
		for e in self.edges:
			
			n1 = e.v1.co
			n2 = e.v2.co
			n3 = e.prev.v1.co
			
			a = n1-n2
			b = n1-n3
			normal1 = Mathutils.CrossVecs(a,b)
			normal1.normalize()
			
			n1 = e.v2.co
			n3 = e.next.v2.co
			n2 = e.v1.co
			
			a = n1-n2
			b = n1-n3
			
			normal2 = Mathutils.CrossVecs(a,b)
			normal2.normalize()
			
			# Reuse normal1 var
			normal1 += normal1 + normal2
			normal1.normalize()
			
			e.normal = normal1
			#print e.normal
		


		
	def backup(self):
		# Keep a backup of the edges
		self.backupEdges = self.edges[:]
			
	def restore(self):
		self.edges = self.backupEdges[:]
		for e in self.edges:
			e.removed = 0
		
	def reverse(self):
		self.edges.reverse()
		for e in self.edges:
			e.normal = -e.normal
			e.v1, e.v2 = e.v2, e.v1
		self.normal = -self.normal
	
	# Removes N Smallest edges and backs up
	def removeSmallest(self, cullNum, otherLoopLen):
		global CULL_METHOD
		if CULL_METHOD == 0: # Shortest edge
			
			eloopCopy = self.edges[:]
			eloopCopy.sort(lambda e1, e2: cmp(e1.length, e2.length )) # Length sort, smallest first
			eloopCopy = eloopCopy[:cullNum]
			for e in eloopCopy:
				e.removed = 1
				self.edges.remove( e ) # Remove from own list, still in linked list.
			
		else: # CULL METHOD is even
				
			culled = 0
			
			step = int(otherLoopLen / float(cullNum))
			
			currentEdge = self.edges[0]
			while culled < cullNum:
				
				# Get the shortest face in the next STEP
				while currentEdge.removed == 1:
					# Bug here!
					currentEdge = currentEdge.next
				smallestEdge = currentEdge
				
				for i in range(step):
					currentEdge = currentEdge.next
					while currentEdge.removed == 1:
						currentEdge = currentEdge.next
					if smallestEdge.length > currentEdge.length:
						smallestEdge = currentEdge
				
				# In that stepping length we have the smallest edge.remove it
				smallestEdge.removed = 1
				self.edges.remove(smallestEdge)
				
				culled+=1
	

# Returns face edges.
# face must have edge data.
def faceEdges(me, f):
	if len(f) == 3:
		return [\
		 me.findEdge(f[0], f[1]),\
		 me.findEdge(f[1], f[2]),\
		 me.findEdge(f[2], f[0])\
		]
	elif len(f) == 4:
		return [\
		 me.findEdge(f[0], f[1]),\
		 me.findEdge(f[1], f[2]),\
		 me.findEdge(f[2], f[3]),\
		 me.findEdge(f[3], f[0])\
		]


def getSelectedEdges(me, ob):	
	SEL_FLAG = NMesh.EdgeFlags['SELECT']
	FGON_FLAG = NMesh.EdgeFlags['FGON']	
	
	edges = [e for e in me.edges if e.flag & SEL_FLAG if (e.flag & FGON_FLAG) == 0 ]
	
	# Now remove edges that face 2 or more selected faces usoing them
	edgeFromSelFaces = []
	for f in me.faces:
		if len(f) >2 and f.sel:
			edgeFromSelFaces.extend(faceEdges(me, f))
	
	# Remove all edges with 2 or more selected faces as uses.
	for e in edgeFromSelFaces:
		if edgeFromSelFaces.count(e) > 1:
			me.removeEdge(e.v1, e.v2)
	
	# Remove selected faces?
	fIdx = len(me.faces)
	while fIdx:
		fIdx-=1
		if len(me.faces[fIdx]) > 2:
			if me.faces[fIdx].sel:
				me.faces.pop(fIdx)
	return [e for e in edges if edgeFromSelFaces.count(e) < 2]
	
	
# Like vert loops 
def getVertLoops(selEdges):
	mainVertLoops = []
	while selEdges:
		e = selEdges.pop()
		contextVertLoop= [e.v1, e.v2] # start the vert loop
		
		eIdx = 1 # Get us into the loop. dummy var.
		
		# if eIdx == 0 then it means we searched and found no matches... 
		# time for a new vert loop,
		while eIdx:
			eIdx = len(selEdges)
			while eIdx:
				eIdx-=1
				
				# Check for edge attached at the head of the loop.
				if contextVertLoop[0] == selEdges[eIdx].v1:
					contextVertLoop.insert(0, selEdges.pop(eIdx).v2)
				elif contextVertLoop[0] == selEdges[eIdx].v2:
					contextVertLoop.insert(0, selEdges.pop(eIdx).v1)
					
				# Chech for edge vert at the tail.
				elif contextVertLoop[-1] == selEdges[eIdx].v1:
					contextVertLoop.append(selEdges.pop(eIdx).v2)
				elif contextVertLoop[-1] == selEdges[eIdx].v2:
					contextVertLoop.append(selEdges.pop(eIdx).v1)
				else:
					# None found? Keep looking
					continue
				
				# Once found we.
				break
		
		# Is this a loop? if so then its forst and last vert must be teh same.
		if contextVertLoop[0].index == contextVertLoop[-1].index:
			contextVertLoop.pop() # remove double vert
			mainVertLoops.append(contextVertLoop)
		
		# Build context vert loops
	return mainVertLoops


def skin2EdgeLoops(eloop1, eloop2, me, ob, MODE):
	# Make sure e1 loops is bigger then e2
	if len(eloop1.edges) != len(eloop2.edges):
		if len(eloop1.edges) < len(eloop2.edges):
			eloop1, eloop2 = eloop2, eloop1
		
		eloop1.backup() # were about to cull faces
		CULL_FACES = len(eloop1.edges) - len(eloop2.edges)
		eloop1.removeSmallest(CULL_FACES, len(eloop1.edges))
	else:
		CULL_FACES = 0
	# First make sure poly vert loops are in sync with eachother.
	
	# The vector allong which we are skinning.
	skinVector = eloop1.centre - eloop2.centre
	
	loopDist = skinVector.length
	
	
	# IS THE LOOP FLIPPED, IF SO FLIP BACK.
	angleBetweenLoopNormals = Mathutils.AngleBetweenVecs(eloop1.normal, eloop2.normal)
	
	if angleBetweenLoopNormals > 90:
		eloop2.reverse()
	
	
	bestEloopDist = BIG_NUM
	bestOffset = 0
	# Loop rotation offset to test.1
	eLoopIdxs = range(len(eloop1.edges))
	for offset in range(len(eloop1.edges)):
		totEloopDist = 0 # Measure this total distance for thsi loop.
		
		offsetIndexLs = eLoopIdxs[offset:] + eLoopIdxs[:offset] # Make offset index list
		
		# e1Idx is always from 0 to N, e2Idx is offset.
		for e1Idx, e2Idx in enumerate(offsetIndexLs):
			# Measure the vloop distance ===============
			totEloopDist += ((eloop1.edges[e1Idx].v1.co - eloop2.edges[e2Idx].v1.co).length / loopDist) #/ nangle1
			totEloopDist += ((eloop1.edges[e1Idx].v2.co - eloop2.edges[e2Idx].v2.co).length / loopDist) #/ nangle1
			
			# Premeture break if where no better off
			if totEloopDist > bestEloopDist:
				break
		
		if totEloopDist < bestEloopDist:
			bestOffset = offset
			bestEloopDist = totEloopDist
	
	# Modify V2 LS for Best offset
	eloop2.edges = eloop2.edges[bestOffset:] + eloop2.edges[:bestOffset]
	
	
	
	for loopIdx in range(len(eloop2.edges)):
		e1 = eloop1.edges[loopIdx]
		e2 = eloop2.edges[loopIdx]
		
		# Remember the pairs for fan filling culled edges.
		e1.match = e2; e2.match = e1
		
		# need some smart face flipping code here.
		f = NMesh.Face([e1.v1, e1.v2, e2.v2, e2.v1])
		
		f.sel = 1
		me.faces.append(f)
	
	# FAN FILL MISSING FACES.
	if CULL_FACES:
		# Culled edges will be in eloop1.
		FAN_FILLED_FACES = 0
		
		contextEdge = eloop1.edges[0] # The larger of teh 2
		while FAN_FILLED_FACES < CULL_FACES:
			while contextEdge.next.removed == 0:
				contextEdge = contextEdge.next
			
			vertFanPivot = contextEdge.match.v2
			
			while contextEdge.next.removed == 1:
				
				f = NMesh.Face([contextEdge.next.v1, contextEdge.next.v2, vertFanPivot] )
				
				
				f.sel = 1
				me.faces.append(f)
				
				# Should we use another var?, this will work for now.
				contextEdge.next.removed = 1
				
				contextEdge = contextEdge.next
				FAN_FILLED_FACES += 1
		
		eloop1.restore() # Add culled back into the list.
	#if angleBetweenLoopNormals > 90:
	#	eloop2.reverse()


def main():
	global CULL_METHOD
	
	is_editmode = Window.EditMode()
	if is_editmode: Window.EditMode(0)
	ob = Scene.GetCurrent().getActiveObject()
	if ob == None or ob.getType() != 'Mesh':
		return
	
	me = ob.getData()
	if not me.edges:
		Draw.PupMenu('Error, add edge data first')
		if is_editmode: Window.EditMode(1)
		return
	
	# BAD BLENDER PYTHON API, NEED TO ENTER EXIT EDIT MODE FOR ADDING EDGE DATA.
	# ADD EDGE DATA HERE, Python API CANT DO IT YET, LOOSES SELECTION
	
	selEdges = getSelectedEdges(me, ob)
	vertLoops = getVertLoops(selEdges) # list of lists of edges.
	
	if len(vertLoops) > 2:
		choice = Draw.PupMenu('Loft '+str(len(vertLoops))+' edge loops%t|loop|segment')
		if choice == -1:
			if is_editmode: Window.EditMode(1)
			return
	elif len(vertLoops) < 2:
		Draw.PupMenu('Error, No Vertloops found%t|if you have a valid selection, go in and out of face edit mode to update the selection state.')
		if is_editmode: Window.EditMode(1)	
		return
	else:
		choice = 2
	
	
	# The line below checks if any of the vert loops are differenyt in length.
	if False in [len(v) == len(vertLoops[0]) for v in vertLoops]:
		CULL_METHOD = Draw.PupMenu('Small to large edge loop distrobution method%t|remove edges evenly|remove smallest edges edges')
		if CULL_METHOD == -1:
			if is_editmode: Window.EditMode(1)
			return
		
		if CULL_METHOD ==1: # RESET CULL_METHOD
			CULL_METHOD = 0 # shortest
		else:
			CULL_METHOD = 1 # even
	
	
	time1 = sys.time()
	# Convert to special edge data.
	edgeLoops = []
	for vloop in vertLoops:
		edgeLoops.append(edgeLoop(vloop))
		
	
	# VERT LOOP ORDERING CODE
	# Build a worm list - grow from Both ends
	edgeOrderedList = [edgeLoops.pop()]
	
	# Find the closest.
	bestSoFar = BIG_NUM
	bestIdxSoFar = None
	for edLoopIdx, edLoop in enumerate(edgeLoops):
		l =(edgeOrderedList[-1].centre - edLoop.centre).length 
		if l < bestSoFar:
			bestIdxSoFar = edLoopIdx
			bestSoFar = l
			
	edgeOrderedList.append( edgeLoops.pop(bestIdxSoFar) )
	
	# Now we have the 2 closest, append to either end-
	# Find the closest.
	while edgeLoops:
		bestSoFar = BIG_NUM
		bestIdxSoFar = None
		first_or_last = 0 # Zero is first
		for edLoopIdx, edLoop in enumerate(edgeLoops):
			l1 =(edgeOrderedList[-1].centre - edLoop.centre).length 
			
			if l1 < bestSoFar:
				bestIdxSoFar = edLoopIdx
				bestSoFar = l1
				first_or_last = 1 # last
			
			l2 =(edgeOrderedList[0].centre - edLoop.centre).length 
			if l2 < bestSoFar:
				bestIdxSoFar = edLoopIdx
				bestSoFar = l2
				first_or_last = 0 # last
		
		if first_or_last: # add closest Last
			edgeOrderedList.append( edgeLoops.pop(bestIdxSoFar) )	
		else: # Add closest First
			edgeOrderedList.insert(0, edgeLoops.pop(bestIdxSoFar) )	 # First
	
	for i in range(len(edgeOrderedList)-1):
		skin2EdgeLoops(edgeOrderedList[i], edgeOrderedList[i+1], me, ob, 0)	
	if choice == 1 and len(edgeOrderedList) > 2: # Loop
		skin2EdgeLoops(edgeOrderedList[0], edgeOrderedList[-1], me, ob, 0)	
	
	print '\nArray done in %.4f sec.' % (sys.time()-time1)
	me.update(1, 1, 0)
	if is_editmode: Window.EditMode(1)

if __name__ == '__main__':
	main()