[Bf-extensions-cvs] SVN commit: /data/svn/bf-extensions [1781] contrib/py/scripts/addons/ mesh_looptools.py: Moved to trunk
Bart Crouch
bartius.crouch at gmail.com
Mon Apr 4 18:01:53 CEST 2011
Revision: 1781
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-extensions&revision=1781
Author: crouch
Date: 2011-04-04 16:01:52 +0000 (Mon, 04 Apr 2011)
Log Message:
-----------
Moved to trunk
Removed Paths:
-------------
contrib/py/scripts/addons/mesh_looptools.py
Deleted: contrib/py/scripts/addons/mesh_looptools.py
===================================================================
--- contrib/py/scripts/addons/mesh_looptools.py 2011-04-04 16:00:53 UTC (rev 1780)
+++ contrib/py/scripts/addons/mesh_looptools.py 2011-04-04 16:01:52 UTC (rev 1781)
@@ -1,3712 +0,0 @@
-# ##### 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# <pep8 compliant>
-
-bl_info = {
- 'name': "LoopTools",
- 'author': "Bart Crouch",
- 'version': (3, 2, 0),
- 'blender': (2, 5, 7),
- 'api': 35979,
- 'location': "View3D > Toolbar and View3D > Specials (W-key)",
- 'warning': "",
- 'description': "Mesh modelling toolkit. Several tools to aid modelling",
- 'wiki_url': "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
- "Scripts/Modeling/LoopTools",
- 'tracker_url': "http://projects.blender.org/tracker/index.php?"\
- "func=detail&aid=26189",
- 'category': 'Mesh'}
-
-
-import bpy
-import mathutils
-import math
-
-
-##########################################
-####### General functions ################
-##########################################
-
-
-# used by all tools to improve speed on reruns
-looptools_cache = {}
-
-
-# force a full recalculation next time
-def cache_delete(tool):
- if tool in looptools_cache:
- del looptools_cache[tool]
-
-
-# check cache for stored information
-def cache_read(tool, object, mesh, input_method, boundaries):
- # current tool not cached yet
- if tool not in looptools_cache:
- return(False, False, False, False, False)
- # check if selected object didn't change
- if object.name != looptools_cache[tool]["object"]:
- return(False, False, False, False, False)
- # check if input didn't change
- if input_method != looptools_cache[tool]["input_method"]:
- return(False, False, False, False, False)
- if boundaries != looptools_cache[tool]["boundaries"]:
- return(False, False, False, False, False)
- modifiers = [mod.name for mod in object.modifiers if mod.show_viewport \
- and mod.type == 'MIRROR']
- if modifiers != looptools_cache[tool]["modifiers"]:
- return(False, False, False, False, False)
- input = [v.index for v in mesh.vertices if v.select and not v.hide]
- if input != looptools_cache[tool]["input"]:
- return(False, False, False, False, False)
- # reading values
- single_loops = looptools_cache[tool]["single_loops"]
- loops = looptools_cache[tool]["loops"]
- derived = looptools_cache[tool]["derived"]
- mapping = looptools_cache[tool]["mapping"]
-
- return(True, single_loops, loops, derived, mapping)
-
-
-# store information in the cache
-def cache_write(tool, object, mesh, input_method, boundaries, single_loops,
-loops, derived, mapping):
- # clear cache of current tool
- if tool in looptools_cache:
- del looptools_cache[tool]
- # prepare values to be saved to cache
- input = [v.index for v in mesh.vertices if v.select and not v.hide]
- modifiers = [mod.name for mod in object.modifiers if mod.show_viewport \
- and mod.type == 'MIRROR']
- # update cache
- looptools_cache[tool] = {"input": input, "object": object.name,
- "input_method": input_method, "boundaries": boundaries,
- "single_loops": single_loops, "loops": loops,
- "derived": derived, "mapping": mapping, "modifiers": modifiers}
-
-
-# calculates natural cubic splines through all given knots
-def calculate_cubic_splines(mesh_mod, tknots, knots):
- # hack for circular loops
- if knots[0] == knots[-1] and len(knots) > 1:
- circular = True
- k_new1 = []
- for k in range(-1, -5, -1):
- if k - 1 < -len(knots):
- k += len(knots)
- k_new1.append(knots[k-1])
- k_new2 = []
- for k in range(4):
- if k + 1 > len(knots) - 1:
- k -= len(knots)
- k_new2.append(knots[k+1])
- for k in k_new1:
- knots.insert(0, k)
- for k in k_new2:
- knots.append(k)
- t_new1 = []
- total1 = 0
- for t in range(-1, -5, -1):
- if t - 1 < -len(tknots):
- t += len(tknots)
- total1 += tknots[t] - tknots[t-1]
- t_new1.append(tknots[0] - total1)
- t_new2 = []
- total2 = 0
- for t in range(4):
- if t + 1 > len(tknots) - 1:
- t -= len(tknots)
- total2 += tknots[t+1] - tknots[t]
- t_new2.append(tknots[-1] + total2)
- for t in t_new1:
- tknots.insert(0, t)
- for t in t_new2:
- tknots.append(t)
- else:
- circular = False
- # end of hack
-
- n = len(knots)
- if n < 2:
- return False
- x = tknots[:]
- locs = [mesh_mod.vertices[k].co[:] for k in knots]
- result = []
- for j in range(3):
- a = []
- for i in locs:
- a.append(i[j])
- h = []
- for i in range(n-1):
- if x[i+1] - x[i] == 0:
- h.append(1e-8)
- else:
- h.append(x[i+1] - x[i])
- q = [False]
- for i in range(1, n-1):
- q.append(3/h[i]*(a[i+1]-a[i]) - 3/h[i-1]*(a[i]-a[i-1]))
- l = [1.0]
- u = [0.0]
- z = [0.0]
- for i in range(1, n-1):
- l.append(2*(x[i+1]-x[i-1]) - h[i-1]*u[i-1])
- if l[i] == 0:
- l[i] = 1e-8
- u.append(h[i] / l[i])
- z.append((q[i] - h[i-1] * z[i-1]) / l[i])
- l.append(1.0)
- z.append(0.0)
- b = [False for i in range(n-1)]
- c = [False for i in range(n)]
- d = [False for i in range(n-1)]
- c[n-1] = 0.0
- for i in range(n-2, -1, -1):
- c[i] = z[i] - u[i]*c[i+1]
- b[i] = (a[i+1]-a[i])/h[i] - h[i]*(c[i+1]+2*c[i])/3
- d[i] = (c[i+1]-c[i]) / (3*h[i])
- for i in range(n-1):
- result.append([a[i], b[i], c[i], d[i], x[i]])
- splines = []
- for i in range(len(knots)-1):
- splines.append([result[i], result[i+n-1], result[i+(n-1)*2]])
- if circular: # cleaning up after hack
- knots = knots[4:-4]
- tknots = tknots[4:-4]
-
- return(splines)
-
-
-# calculates linear splines through all given knots
-def calculate_linear_splines(mesh_mod, tknots, knots):
- splines = []
- for i in range(len(knots)-1):
- a = mesh_mod.vertices[knots[i]].co
- b = mesh_mod.vertices[knots[i+1]].co
- d = b-a
- t = tknots[i]
- u = tknots[i+1]-t
- splines.append([a, d, t, u]) # [locStart, locDif, tStart, tDif]
-
- return(splines)
-
-
-# calculate a best-fit plane to the given vertices
-def calculate_plane(mesh_mod, loop, method="best_fit", object=False):
- # getting the vertex locations
- locs = [mathutils.Vector(mesh_mod.vertices[v].co[:]) for v in loop[0]]
-
- # calculating the center of masss
- com = mathutils.Vector()
- for loc in locs:
- com += loc
- com /= len(locs)
- x, y, z = com
-
- if method == 'best_fit':
- # creating the covariance matrix
- mat = mathutils.Matrix([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0],
- [0.0, 0.0, 0.0]])
- for loc in locs:
- mat[0][0] += (loc[0]-x)**2
- mat[0][1] += (loc[0]-x)*(loc[1]-y)
- mat[0][2] += (loc[0]-x)*(loc[2]-z)
- mat[1][0] += (loc[1]-y)*(loc[0]-x)
- mat[1][1] += (loc[1]-y)**2
- mat[1][2] += (loc[1]-y)*(loc[2]-z)
- mat[2][0] += (loc[2]-z)*(loc[0]-x)
- mat[2][1] += (loc[2]-z)*(loc[1]-y)
- mat[2][2] += (loc[2]-z)**2
-
- # calculating the normal to the plane
- normal = False
- try:
- mat.invert()
- except:
- if sum(mat[0]) == 0.0:
- normal = mathutils.Vector([1.0, 0.0, 0.0])
- elif sum(mat[1]) == 0.0:
- normal = mathutils.Vector([0.0, 1.0, 0.0])
- elif sum(mat[2]) == 0.0:
- normal = mathutils.Vector([0.0, 0.0, 1.0])
- if not normal:
- itermax = 500
- iter = 0
- vec = mathutils.Vector([1.0, 1.0, 1.0])
- vec2 = (vec*mat)/(vec*mat).length
- while vec != vec2 and iter<itermax:
- iter += 1
- vec = vec2
- vec2 = (vec*mat)/(vec*mat).length
- normal = vec2
-
- elif method == 'normal':
- # averaging the vertex normals
- v_normals = [mesh_mod.vertices[v].normal for v in loop[0]]
- normal = mathutils.Vector()
- for v_normal in v_normals:
- normal += v_normal
- normal /= len(v_normals)
- normal.normalize()
-
- elif method == 'view':
- # calculate view normal
- rotation = bpy.context.space_data.region_3d.view_matrix.to_3x3().\
- inverted()
- normal = mathutils.Vector([0.0, 0.0, 1.0]) * rotation
- if object:
- normal *= object.matrix_world.inverted().to_euler().to_matrix()
-
- return(com, normal)
-
-
-# calculate splines based on given interpolation method (controller function)
-def calculate_splines(interpolation, mesh_mod, tknots, knots):
- if interpolation == 'cubic':
- splines = calculate_cubic_splines(mesh_mod, tknots, knots[:])
- else: # interpolations == 'linear'
- splines = calculate_linear_splines(mesh_mod, tknots, knots[:])
-
- return(splines)
-
-
-# check loops and only return valid ones
-def check_loops(loops, mapping, mesh_mod):
- valid_loops = []
- for loop, circular in loops:
- # loop needs to have at least 3 vertices
- if len(loop) < 3:
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-extensions-cvs
mailing list