forked from bartvdbraak/blender
452c8cf838
Scripts: - Jean-Michel Soler probably lost some hours of sleep since Sunday, but he managed to send me the updated path import scripts a few hours ago. My tests with Inkscape .svg and .ps and Gimp worked fine. He also tested a lot and sent me info about what is already supported. I'll send Ton a doc about bundled scripts including this info. Importers: .ai, .svg, .eps/.ps, Gimp 1-1.2.5 / 2.0. - Jean-Michel also contributed his Texture Baker script. - Campbell Barton contributed two new scripts: a mesh cleaner and a vloop skinning / lofting script. He also sent updates to his obj import / export ones. - A Vanpoucke (xand) contributed his Axis Orientation Copy script. And that makes 8 last minute additions. Thanks a lot to the authors and special thanks to JMS and Campbell for their hard work : ). BPython: - tiny addition (I'm forced to call it a showstopper bug ;) so JMS's path import scripts (that actually convert to obj and make Blender load the .obj curves) can use Blender.Load() and not rename G.sce, the default filename. Blender.Load(filename, 1) doesn't update G.sce. Nothing should break because of this, Load(filename) still works fine. - Made Blender complain again if script is for a newer Blender version than the one running it.
559 lines
16 KiB
Python
559 lines
16 KiB
Python
#!BPY
|
|
|
|
"""
|
|
Name: 'Skin Two Vert-loops / Loft Multiple'
|
|
Blender: 234
|
|
Group: 'Mesh'
|
|
Submenu: 'Loft-loop - shortest edge method' A1
|
|
Submenu: 'Loft-loop - even method' A2
|
|
Submenu: 'Loft-segment - shortest edge' B1
|
|
Submenu: 'Loft-segment - even method' B2
|
|
Tooltip: 'Select 2 or more vert loops, then run this script'
|
|
"""
|
|
|
|
# $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 2004/04/25 - ideasman@linuxmail.org
|
|
|
|
import Blender
|
|
from Blender import *
|
|
import math
|
|
from math import *
|
|
arg = __script__['arg']
|
|
|
|
|
|
#================#
|
|
# Math functions #
|
|
#================#
|
|
|
|
# Measure 2 points
|
|
def measure(v1, v2):
|
|
return Mathutils.Vector([v1[0]-v2[0], v1[1] - v2[1], v1[2] - v2[2]]).length
|
|
|
|
# Clamp
|
|
def clamp(max, number):
|
|
while number >= max:
|
|
number = number - max
|
|
return number
|
|
|
|
#=============================================================#
|
|
# List func that takes the last item and adds it to the front #
|
|
#=============================================================#
|
|
def listRotate(ls):
|
|
return [ls[-1]] + ls[:-1]
|
|
|
|
#=================================================================#
|
|
# Recieve a list of locs: [x,y,z] and return the average location #
|
|
#=================================================================#
|
|
def averageLocation(locList):
|
|
avLoc = [0,0,0]
|
|
|
|
# Loop through x/y/z
|
|
for coordIdx in [0,1,2]:
|
|
|
|
# Add all the values from 1 of the 3 coords at the avLoc.
|
|
for loc in locList:
|
|
avLoc[coordIdx] += loc[coordIdx]
|
|
|
|
avLoc[coordIdx] = avLoc[coordIdx] / len(locList)
|
|
return avLoc
|
|
|
|
|
|
|
|
#=============================#
|
|
# Blender functions/shortcuts #
|
|
#=============================#
|
|
def error(str):
|
|
Draw.PupMenu('ERROR%t|'+str)
|
|
|
|
# Returns a new face that has the same properties as the origional face
|
|
# With no verts though
|
|
def copyFace(face):
|
|
newFace = NMesh.Face()
|
|
# Copy some generic properties
|
|
newFace.mode = face.mode
|
|
if face.image != None:
|
|
newFace.image = face.image
|
|
newFace.flag = face.flag
|
|
newFace.mat = face.mat
|
|
newFace.smooth = face.smooth
|
|
return newFace
|
|
|
|
#=============================================#
|
|
# Find a selected vert that 2 faces share. #
|
|
#=============================================#
|
|
def selVertBetween2Faces(face1, face2):
|
|
for v1 in face1.v:
|
|
if v1.sel:
|
|
for v2 in face2.v:
|
|
if v1 == v2:
|
|
return v1
|
|
|
|
|
|
#=======================================================#
|
|
# Measure the total distance between all the edges in #
|
|
# 2 vertex loops #
|
|
#=======================================================#
|
|
def measureVloop(mesh, v1loop, v2loop, surplusFaces):
|
|
totalDist = 0
|
|
|
|
# Rotate the vertloops to cycle through each pair.
|
|
# of faces to compate the distance between the 2 poins
|
|
for ii in range(len(v1loop)):
|
|
if ii not in surplusFaces:
|
|
V1 = selVertBetween2Faces(mesh.faces[v1loop[0]], mesh.faces[v1loop[1]])
|
|
V2 = selVertBetween2Faces(mesh.faces[v2loop[0]], mesh.faces[v2loop[1]])
|
|
|
|
P1 = (V1[0],V1[1],V1[2])
|
|
P2 = (V2[0],V2[1],V2[2])
|
|
|
|
totalDist += measure(P1,P2)
|
|
v1loop = listRotate(v1loop)
|
|
v2loop = listRotate(v2loop)
|
|
|
|
#selVertBetween2Faces(mesh.faces[v2loop[0]], mesh.faces[v2loop[1]])
|
|
return totalDist
|
|
|
|
# Remove the shortest edge from a vert loop
|
|
def removeSmallestFace(mesh, vloop):
|
|
bestDistSoFar = None
|
|
bestFIdxSoFar = None
|
|
for fIdx in vloop:
|
|
vSelLs = []
|
|
for v in mesh.faces[fIdx].v:
|
|
if v.sel:
|
|
vSelLs.append(v)
|
|
|
|
dist = measure(vSelLs[0].co, vSelLs[1].co)
|
|
|
|
if bestDistSoFar == None:
|
|
bestDistSoFar = dist
|
|
bestFIdxSoFar = fIdx
|
|
elif dist < bestDistSoFar:
|
|
bestDistSoFar = dist
|
|
bestFIdxSoFar = fIdx
|
|
|
|
# Return the smallest face index of the vloop that was sent
|
|
return bestFIdxSoFar
|
|
|
|
|
|
#=============================================#
|
|
# Take 2 vert loops and skin them #
|
|
#=============================================#
|
|
def skinVertLoops(mesh, v1loop, v2loop):
|
|
|
|
|
|
#=============================================#
|
|
# Handle uneven vert loops, this is tricky #
|
|
#=============================================#
|
|
# Reorder so v1loop is always the biggest
|
|
if len(v1loop) < len(v2loop):
|
|
v1loop, v2loop = v2loop, v1loop
|
|
|
|
# Work out if the vert loops are equel or not, if not remove the extra faces from the larger
|
|
surplusFaces = []
|
|
tempv1loop = eval(str(v1loop)) # strip faces off this one, use it to keep track of which we have taken faces from.
|
|
if len(v1loop) > len(v2loop):
|
|
|
|
# Even face method.
|
|
if arg[1] == '2':
|
|
remIdx = 0
|
|
faceStepping = len( v1loop) / len(v2loop)
|
|
while len(v1loop) - len(surplusFaces) > len(v2loop):
|
|
remIdx += faceStepping
|
|
surplusFaces.append(tempv1loop[ clamp(len(tempv1loop),remIdx) ])
|
|
tempv1loop.remove(surplusFaces[-1])
|
|
|
|
# Shortest face
|
|
elif arg[1] == '1':
|
|
while len(v1loop) - len(surplusFaces) > len(v2loop):
|
|
surplusFaces.append(removeSmallestFace(mesh, tempv1loop))
|
|
tempv1loop.remove(surplusFaces[-1])
|
|
|
|
|
|
tempv1loop = None
|
|
|
|
v2loop = optimizeLoopOrdedShortEdge(mesh, v1loop, v2loop, surplusFaces)
|
|
|
|
# make Faces from
|
|
lenVloop = len(v1loop)
|
|
lenSupFaces = len(surplusFaces)
|
|
fIdx = 0
|
|
offset = 0
|
|
while fIdx < lenVloop:
|
|
|
|
face = copyFace( mesh.faces[v1loop[clamp(lenVloop, fIdx+1)]] )
|
|
|
|
if v1loop[fIdx] in surplusFaces:
|
|
# Draw a try, this face does not catch with an edge.
|
|
# So we must draw a tri and wedge it in.
|
|
|
|
# Copy old faces properties
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx)]],\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx+1)]]) )
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx+1)]],\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx+2)]]) )
|
|
|
|
#face.v.append( selVertBetween2Faces(\
|
|
#mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, (fIdx - offset +1 ))]],\
|
|
#mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, (fIdx - offset + 2))]]) )
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, (fIdx - offset))]],\
|
|
mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, fIdx - offset + 1)]]) )
|
|
|
|
mesh.faces.append(face)
|
|
|
|
# We need offset to work out how much smaller v2loop is at this current index.
|
|
offset+=1
|
|
|
|
|
|
else:
|
|
# Draw a normal quad between the 2 edges/faces
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx)]],\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx+1)]]) )
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx+1)]],\
|
|
mesh.faces[v1loop[clamp(lenVloop, fIdx+2)]]) )
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, (fIdx - offset +1 ))]],\
|
|
mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, (fIdx - offset + 2))]]) )
|
|
|
|
face.v.append( selVertBetween2Faces(\
|
|
mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, (fIdx - offset))]],\
|
|
mesh.faces[v2loop[clamp(lenVloop - lenSupFaces, fIdx - offset + 1)]]) )
|
|
|
|
mesh.faces.append(face)
|
|
|
|
fIdx +=1
|
|
|
|
return mesh
|
|
|
|
|
|
|
|
#=======================================================#
|
|
# Takes a face and returns the number of selected verts #
|
|
#=======================================================#
|
|
def faceVSel(face):
|
|
vSel = 0
|
|
for v in face.v:
|
|
if v.sel:
|
|
vSel +=1
|
|
return vSel
|
|
|
|
|
|
|
|
|
|
#================================================================#
|
|
# This function takes a face and returns its selected vert loop #
|
|
# it returns a list of face indicies
|
|
#================================================================#
|
|
def vertLoop(mesh, startFaceIdx, fIgLs): # fIgLs is a list of faces to ignore.
|
|
# Here we store the faces indicies that
|
|
# are a part of the first vertex loop
|
|
vertLoopLs = [startFaceIdx]
|
|
|
|
restart = 0
|
|
while restart == 0:
|
|
# this keeps the face loop going until its told to stop,
|
|
# If the face loop does not find an adjacent face then the vert loop has been compleated
|
|
restart = 1
|
|
|
|
# Get my selected verts for the active face/edge.
|
|
selVerts = []
|
|
for v in mesh.faces[vertLoopLs[-1]].v:
|
|
selVerts.append(v)
|
|
|
|
fIdx = 0
|
|
while fIdx < len(mesh.faces) and restart:
|
|
# Not already added to the vert list
|
|
if fIdx not in fIgLs + vertLoopLs:
|
|
# Has 2 verts selected
|
|
if faceVSel(mesh.faces[fIdx]) > 1:
|
|
# Now we need to find if any of the selected verts
|
|
# are shared with our active face. (are we next to ActiveFace)
|
|
for v in mesh.faces[fIdx].v:
|
|
if v in selVerts:
|
|
vertLoopLs.append(fIdx)
|
|
restart = 0 # restart the face loop.
|
|
break
|
|
|
|
fIdx +=1
|
|
|
|
return vertLoopLs
|
|
|
|
|
|
|
|
|
|
#================================================================#
|
|
# Now we work out the optimum order to 'skin' the 2 vert loops #
|
|
# by measuring the total distance of all edges created, #
|
|
# test this for every possible series of joins #
|
|
# and find the shortest, Once this is done the #
|
|
# shortest dist can be skinned. #
|
|
# returns only the 2nd-reordered vert loop #
|
|
#================================================================#
|
|
def optimizeLoopOrded(mesh, v1loop, v2loop):
|
|
bestSoFar = None
|
|
|
|
# Measure the dist, ii is just a counter
|
|
for ii in range(len(v1loop)):
|
|
|
|
# Loop twice , Once for the forward test, and another for the revearsed
|
|
for iii in [0, 0]:
|
|
dist = measureVloop(mesh, v1loop, v2loop)
|
|
# Initialize the Best distance recorded
|
|
if bestSoFar == None:
|
|
bestSoFar = dist
|
|
bestv2Loop = eval(str(v2loop))
|
|
|
|
elif dist < bestSoFar: # Update the info if a better vloop rotation is found.
|
|
bestSoFar = dist
|
|
bestv2Loop = eval(str(v2loop))
|
|
|
|
# We might have got the vert loop backwards, try the other way
|
|
v2loop.reverse()
|
|
v2loop = listRotate(v2loop)
|
|
return bestv2Loop
|
|
|
|
|
|
|
|
#================================================================#
|
|
# Now we work out the optimum order to 'skin' the 2 vert loops #
|
|
# by measuring the total distance of all edges created, #
|
|
# test this for every possible series of joins #
|
|
# and find the shortest, Once this is done the #
|
|
# shortest dist can be skinned. #
|
|
# returns only the 2nd-reordered vert loop #
|
|
#================================================================#
|
|
def optimizeLoopOrdedShortEdge(mesh, v1loop, v2loop, surplusFaces):
|
|
bestSoFar = None
|
|
|
|
# Measure the dist, ii is just a counter
|
|
for ii in range(len(v2loop)):
|
|
|
|
# Loop twice , Once for the forward test, and another for the revearsed
|
|
for iii in [0, 0]:
|
|
dist = measureVloop(mesh, v1loop, v2loop, surplusFaces)
|
|
print 'dist', dist
|
|
# Initialize the Best distance recorded
|
|
if bestSoFar == None:
|
|
bestSoFar = dist
|
|
bestv2Loop = eval(str(v2loop))
|
|
|
|
elif dist < bestSoFar: # Update the info if a better vloop rotation is found.
|
|
bestSoFar = dist
|
|
bestv2Loop = eval(str(v2loop))
|
|
|
|
# We might have got the vert loop backwards, try the other way
|
|
v2loop.reverse()
|
|
v2loop = listRotate(v2loop)
|
|
print 'best so far ', bestSoFar
|
|
return bestv2Loop
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#==============================#
|
|
# Find our vert loop list #
|
|
#==============================#
|
|
# Find a face with 2 verts selected,
|
|
#this will be the first face in out vert loop
|
|
def findVertLoop(mesh, fIgLs): # fIgLs is a list of faces to ignore.
|
|
|
|
startFaceIdx = None
|
|
|
|
fIdx = 0
|
|
while fIdx < len(mesh.faces):
|
|
if fIdx not in fIgLs:
|
|
# Do we have an edge?
|
|
if faceVSel(mesh.faces[fIdx]) > 1:
|
|
# THIS IS THE STARTING FACE.
|
|
startFaceIdx = fIdx
|
|
break
|
|
fIdx+=1
|
|
|
|
# Here we access the function that generates the real vert loop
|
|
if startFaceIdx != None:
|
|
return vertLoop(mesh, startFaceIdx, fIgLs)
|
|
else:
|
|
# We are out'a vert loops, return a None,
|
|
return None
|
|
|
|
#===================================#
|
|
# Get the average loc of a vertloop #
|
|
# This is used when working out the #
|
|
# order to loft an object #
|
|
#===================================#
|
|
def vLoopAverageLoc(mesh, vertLoop):
|
|
locList = [] # List of vert locations
|
|
|
|
fIdx = 0
|
|
while fIdx < len(mesh.faces):
|
|
if fIdx in vertLoop:
|
|
for v in mesh.faces[fIdx].v:
|
|
if v.sel:
|
|
locList.append(v.co)
|
|
fIdx+=1
|
|
|
|
return averageLocation(locList)
|
|
|
|
|
|
|
|
#=================================================#
|
|
# Vert loop group functions
|
|
|
|
def getAllVertLoops(mesh):
|
|
# Make a chain of vert loops.
|
|
fIgLs = [] # List of faces to ignore
|
|
allVLoops = [findVertLoop(mesh, fIgLs)]
|
|
while allVLoops[-1] != None:
|
|
|
|
# In future ignore all faces in this vert loop
|
|
fIgLs += allVLoops[-1]
|
|
|
|
# Add the new vert loop to the list
|
|
allVLoops.append( findVertLoop(mesh, fIgLs) )
|
|
|
|
return allVLoops[:-1] # Remove the last Value- None.
|
|
|
|
|
|
def reorderCircularVLoops(mesh, allVLoops):
|
|
# Now get a location for each vert loop.
|
|
allVertLoopLocs = []
|
|
for vLoop in allVLoops:
|
|
allVertLoopLocs.append( vLoopAverageLoc(mesh, vLoop) )
|
|
|
|
# We need to find the longest distance between 2 vert loops so we can
|
|
reorderedVLoopLocs = []
|
|
|
|
# Start with this one, then find the next closest.
|
|
# in doing this make a new list called reorderedVloop
|
|
currentVLoop = 0
|
|
reorderedVloopIdx = [currentVLoop]
|
|
newOrderVLoops = [allVLoops[0]] # This is a re-ordered allVLoops
|
|
while len(reorderedVloopIdx) != len(allVLoops):
|
|
bestSoFar = None
|
|
bestVIdxSoFar = None
|
|
for vLoopIdx in range(len(allVLoops)):
|
|
if vLoopIdx not in reorderedVloopIdx + [currentVLoop]:
|
|
if bestSoFar == None:
|
|
bestSoFar = measure( allVertLoopLocs[vLoopIdx], allVertLoopLocs[currentVLoop] )
|
|
bestVIdxSoFar = vLoopIdx
|
|
else:
|
|
newDist = measure( allVertLoopLocs[vLoopIdx], allVertLoopLocs[currentVLoop] )
|
|
if newDist < bestSoFar:
|
|
bestSoFar = newDist
|
|
bestVIdxSoFar = vLoopIdx
|
|
|
|
reorderedVloopIdx.append(bestVIdxSoFar)
|
|
reorderedVLoopLocs.append(allVertLoopLocs[bestVIdxSoFar])
|
|
newOrderVLoops.append( allVLoops[bestVIdxSoFar] )
|
|
|
|
# Start looking for the next best fit
|
|
currentVLoop = bestVIdxSoFar
|
|
|
|
# This is not the locicle place to put this but its convieneint.
|
|
# Here we find the 2 vert loops that are most far apart
|
|
# We use this to work out which 2 vert loops not to skin when making an open loft.
|
|
vLoopIdx = 0
|
|
# Longest measured so far - 0 dummy.
|
|
bestSoFar = 0
|
|
while vLoopIdx < len(reorderedVLoopLocs):
|
|
|
|
|
|
# Skin back to the start if needs be, becuase this is a crcular loft
|
|
toSkin2 = vLoopIdx + 1
|
|
if toSkin2 == len(reorderedVLoopLocs):
|
|
toSkin2 = 0
|
|
|
|
|
|
newDist = measure( reorderedVLoopLocs[vLoopIdx], reorderedVLoopLocs[toSkin2] )
|
|
|
|
if newDist >= bestSoFar:
|
|
bestSoFar = newDist
|
|
vLoopIdxNotToSkin = vLoopIdx + 1
|
|
|
|
vLoopIdx +=1
|
|
|
|
return newOrderVLoops, vLoopIdxNotToSkin
|
|
|
|
|
|
is_editmode = Window.EditMode()
|
|
if is_editmode: Window.EditMode(0)
|
|
|
|
# Get a mesh and raise errors if we cant
|
|
mesh = None
|
|
if len(Object.GetSelected()) > 0:
|
|
if Object.GetSelected()[0].getType() == 'Mesh':
|
|
mesh = Object.GetSelected()[0].getData()
|
|
else:
|
|
error('please select a mesh')
|
|
else:
|
|
error('no mesh object selected')
|
|
|
|
|
|
if mesh != None:
|
|
allVLoops = getAllVertLoops(mesh)
|
|
|
|
# Re order the vert loops
|
|
allVLoops, vLoopIdxNotToSkin = reorderCircularVLoops(mesh, allVLoops)
|
|
|
|
vloopIdx = 0
|
|
while vloopIdx < len(allVLoops):
|
|
#print range(len(allVLoops) )
|
|
#print vloopIdx
|
|
#print allVLoops[vloopIdx]
|
|
|
|
# Skin back to the start if needs be, becuase this is a crcular loft
|
|
toSkin2 = vloopIdx + 1
|
|
if toSkin2 == len(allVLoops):
|
|
toSkin2 = 0
|
|
|
|
# Circular loft or not?
|
|
if arg[0] == 'B': # B for open
|
|
if vloopIdx != vLoopIdxNotToSkin:
|
|
mesh = skinVertLoops(mesh, allVLoops[vloopIdx], allVLoops[toSkin2])
|
|
elif arg[0] == 'A': # A for closed
|
|
mesh = skinVertLoops(mesh, allVLoops[vloopIdx], allVLoops[toSkin2])
|
|
|
|
vloopIdx +=1
|
|
|
|
mesh.update()
|
|
|
|
if is_editmode: Window.EditMode(1)
|