[Bf-extensions-cvs] [5858c59] master: Curve Simplify: Cleanup, remove dead code
lijenstina
noreply at git.blender.org
Sun Apr 2 22:29:40 CEST 2017
Commit: 5858c59db11fae85dc6ca622d8a202767f837a38
Author: lijenstina
Date: Sun Apr 2 22:28:43 2017 +0200
Branches: master
https://developer.blender.org/rBA5858c59db11fae85dc6ca622d8a202767f837a38
Curve Simplify: Cleanup, remove dead code
Bumped version to 1.0.2
Pep8 cleanup
imports as tuples
Removed two empty Menu classes:
CurveMenu and GRAPH_OT_simplifyf
and unused UI code
Small UI and tooltip fixes
Consistent Props declarations
TO DO: see if the different Algo
UI options can be re-enabled
===================================================================
M curve_simplify.py
===================================================================
diff --git a/curve_simplify.py b/curve_simplify.py
index 6309c78..d1e8e17 100644
--- a/curve_simplify.py
+++ b/curve_simplify.py
@@ -19,12 +19,12 @@
bl_info = {
"name": "Simplify Curves",
"author": "testscreenings",
- "version": (1, 0, 1),
+ "version": (1, 0, 2),
"blender": (2, 75, 0),
"location": "Search > Simplify Curves",
"description": "Simplifies 3D Curve objects and animation F-Curves",
"warning": "",
- "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
+ "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
"Scripts/Curve/Curve_Simplify",
"category": "Add Curve",
}
@@ -33,78 +33,84 @@ bl_info = {
This script simplifies Curve objects and animation F-Curves.
"""
-####################################################
import bpy
-from bpy.props import *
-import mathutils
-import math
+from bpy.props import (
+ BoolProperty,
+ EnumProperty,
+ FloatProperty,
+ IntProperty,
+ )
+from mathutils import Vector
+from math import (
+ sin,
+ pow,
+ )
+from bpy.types import Operator
-from bpy.types import Menu
+# Check for curve
- ## Check for curve
+# ### simplipoly algorithm ###
-##############################
-#### simplipoly algorithm ####
-##############################
# get SplineVertIndices to keep
def simplypoly(splineVerts, options):
# main vars
- newVerts = [] # list of vertindices to keep
- points = splineVerts # list of 3dVectors
- pointCurva = [] # table with curvatures
- curvatures = [] # averaged curvatures per vert
+ newVerts = [] # list of vertindices to keep
+ points = splineVerts # list of 3dVectors
+ pointCurva = [] # table with curvatures
+ curvatures = [] # averaged curvatures per vert
for p in points:
pointCurva.append([])
- order = options[3] # order of sliding beziercurves
- k_thresh = options[2] # curvature threshold
- dis_error = options[6] # additional distance error
+ order = options[3] # order of sliding beziercurves
+ k_thresh = options[2] # curvature threshold
+ dis_error = options[6] # additional distance error
# get curvatures per vert
- for i, point in enumerate(points[:-(order-1)]):
- BVerts = points[i:i+order]
- for b, BVert in enumerate(BVerts[1:-1]):
- deriv1 = getDerivative(BVerts, 1/(order-1), order-1)
- deriv2 = getDerivative(BVerts, 1/(order-1), order-2)
+ for i, point in enumerate(points[: -(order - 1)]):
+ BVerts = points[i: i + order]
+ for b, BVert in enumerate(BVerts[1: -1]):
+ deriv1 = getDerivative(BVerts, 1 / (order - 1), order - 1)
+ deriv2 = getDerivative(BVerts, 1 / (order - 1), order - 2)
curva = getCurvature(deriv1, deriv2)
- pointCurva[i+b+1].append(curva)
+ pointCurva[i + b + 1].append(curva)
# average the curvatures
for i in range(len(points)):
- avgCurva = sum(pointCurva[i]) / (order-1)
+ avgCurva = sum(pointCurva[i]) / (order - 1)
curvatures.append(avgCurva)
# get distancevalues per vert - same as Ramer-Douglas-Peucker
# but for every vert
- distances = [0.0] #first vert is always kept
- for i, point in enumerate(points[1:-1]):
- dist = altitude(points[i], points[i+2], points[i+1])
+ distances = [0.0] # first vert is always kept
+ for i, point in enumerate(points[1: -1]):
+ dist = altitude(points[i], points[i + 2], points[i + 1])
distances.append(dist)
- distances.append(0.0) # last vert is always kept
+ distances.append(0.0) # last vert is always kept
- # generate list of vertindices to keep
+ # generate list of vert indices to keep
# tested against averaged curvatures and distances of neighbour verts
- newVerts.append(0) # first vert is always kept
+ newVerts.append(0) # first vert is always kept
for i, curv in enumerate(curvatures):
- if (curv >= k_thresh*0.01
- or distances[i] >= dis_error*0.1):
+ if (curv >= k_thresh * 0.01 or distances[i] >= dis_error * 0.1):
newVerts.append(i)
- newVerts.append(len(curvatures)-1) # last vert is always kept
+ newVerts.append(len(curvatures) - 1) # last vert is always kept
return newVerts
+
# get binomial coefficient
def binom(n, m):
- b = [0] * (n+1)
+ b = [0] * (n + 1)
b[0] = 1
- for i in range(1, n+1):
+ for i in range(1, n + 1):
b[i] = 1
- j = i-1
+ j = i - 1
while j > 0:
- b[j] += b[j-1]
- j-= 1
+ b[j] += b[j - 1]
+ j -= 1
return b[m]
+
# get nth derivative of order(len(verts)) bezier curve
def getDerivative(verts, t, nth):
order = len(verts) - 1 - nth
@@ -115,34 +121,35 @@ def getDerivative(verts, t, nth):
if QVerts:
verts = QVerts
derivVerts = []
- for i in range(len(verts)-1):
- derivVerts.append(verts[i+1] - verts[i])
+ for i in range(len(verts) - 1):
+ derivVerts.append(verts[i + 1] - verts[i])
QVerts = derivVerts
else:
QVerts = verts
if len(verts[0]) == 3:
- point = mathutils.Vector((0, 0, 0))
+ point = Vector((0, 0, 0))
if len(verts[0]) == 2:
- point = mathutils.Vector((0, 0))
+ point = Vector((0, 0))
for i, vert in enumerate(QVerts):
- point += binom(order, i) * math.pow(t, i) * math.pow(1-t, order-i) * vert
+ point += binom(order, i) * pow(t, i) * pow(1 - t, order - i) * vert
deriv = point
return deriv
+
# get curvature from first, second derivative
def getCurvature(deriv1, deriv2):
- if deriv1.length == 0: # in case of points in straight line
+ if deriv1.length == 0: # in case of points in straight line
curvature = 0
return curvature
- curvature = (deriv1.cross(deriv2)).length / math.pow(deriv1.length, 3)
+ curvature = (deriv1.cross(deriv2)).length / pow(deriv1.length, 3)
return curvature
-#########################################
-#### Ramer-Douglas-Peucker algorithm ####
-#########################################
+
+# ### Ramer-Douglas-Peucker algorithm ###
+
# get altitude of vert
def altitude(point1, point2, pointn):
edge1 = point2 - point1
@@ -154,61 +161,58 @@ def altitude(point1, point2, pointn):
altitude = edge2.length
return altitude
alpha = edge1.angle(edge2)
- altitude = math.sin(alpha) * edge2.length
+ altitude = sin(alpha) * edge2.length
return altitude
+
# iterate through verts
def iterate(points, newVerts, error):
new = []
- for newIndex in range(len(newVerts)-1):
+ for newIndex in range(len(newVerts) - 1):
bigVert = 0
alti_store = 0
- for i, point in enumerate(points[newVerts[newIndex]+1:newVerts[newIndex+1]]):
- alti = altitude(points[newVerts[newIndex]], points[newVerts[newIndex+1]], point)
+ for i, point in enumerate(points[newVerts[newIndex] + 1: newVerts[newIndex + 1]]):
+ alti = altitude(points[newVerts[newIndex]], points[newVerts[newIndex + 1]], point)
if alti > alti_store:
alti_store = alti
if alti_store >= error:
- bigVert = i+1+newVerts[newIndex]
+ bigVert = i + 1 + newVerts[newIndex]
if bigVert:
new.append(bigVert)
if new == []:
return False
return new
-#### get SplineVertIndices to keep
+
+# get SplineVertIndices to keep
def simplify_RDP(splineVerts, options):
- #main vars
+ # main vars
error = options[4]
# set first and last vert
- newVerts = [0, len(splineVerts)-1]
+ newVerts = [0, len(splineVerts) - 1]
# iterate through the points
new = 1
- while new != False:
+ while new is not False:
new = iterate(splineVerts, newVerts, error)
if new:
newVerts += new
newVerts.sort()
return newVerts
-##########################
-#### CURVE GENERATION ####
-##########################
-# set bezierhandles to auto
-def setBezierHandles(newCurve):
- #bpy.ops.object.mode_set(mode='EDIT', toggle=True)
- #bpy.ops.curve.select_all(action='SELECT')
- #bpy.ops.curve.handle_type_set(type='AUTOMATIC')
- #bpy.ops.object.mode_set(mode='OBJECT', toggle=True)
+# ### CURVE GENERATION ###
+# set bezierhandles to auto
+def setBezierHandles(newCurve):
# Faster:
for spline in newCurve.data.splines:
for p in spline.bezier_points:
p.handle_left_type = 'AUTO'
p.handle_right_type = 'AUTO'
+
# get array of new coords for new spline from vertindices
def vertsToPoints(newVerts, splineVerts, splineType):
# main vars
@@ -224,18 +228,15 @@ def vertsToPoints(newVerts, splineVerts, splineType):
for v in newVerts:
newPoints += (splineVerts[v].to_tuple())
if splineType == 'NURBS':
- newPoints.append(1) #for nurbs w=1
- else: #for poly w=0
+ newPoints.append(1) # for nurbs w = 1
+ else: # for poly w = 0
newPoints.append(0)
return newPoints
-#########################
-#### MAIN OPERATIONS ####
-#########################
+
+# ### MAIN OPERATIONS ###
def main(context, obj, options):
- #print("\n_______START_______")
- # main vars
mode = options[0]
output = options[1]
degreeOut = options[5]
@@ -245,24 +246,24 @@ def main(context, obj, options):
splines = obj.data.splines.values()
# create curvedatablock
- curve = bpy.data.curves.new("Simple_"+obj.name, type = 'CURVE')
+ curve = bpy.data.curves.new("Simple_" + obj.name, type='CURVE')
# go through splines
for spline_i, spline in enumerate(splines):
# test if spline is a long enough
if len(spline.points) >= 7 or keepShort:
- #check what type of spline to create
+ # check what type of spline to create
if outp
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-extensions-cvs
mailing list