3f821270e3c66ad73efb127c6cc2f0495ec61ef7
[blender.git] / release / scripts / modules / mocap_tools.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8 compliant>
20
21 from math import hypot, sqrt, isfinite, radians, pi
22 import bpy
23 import time
24 from mathutils import Vector, Matrix
25
26
27 #Vector utility functions
28 class NdVector:
29     vec = []
30
31     def __init__(self, vec):
32         self.vec = vec[:]
33
34     def __len__(self):
35         return len(self.vec)
36
37     def __mul__(self, otherMember):
38         if (isinstance(otherMember, int) or
39             isinstance(otherMember, float)):
40             return NdVector([otherMember * x for x in self.vec])
41         else:
42             a = self.vec
43             b = otherMember.vec
44             n = len(self)
45             return sum([a[i] * b[i] for i in range(n)])
46
47     def __sub__(self, otherVec):
48         a = self.vec
49         b = otherVec.vec
50         n = len(self)
51         return NdVector([a[i] - b[i] for i in range(n)])
52
53     def __add__(self, otherVec):
54         a = self.vec
55         b = otherVec.vec
56         n = len(self)
57         return NdVector([a[i] + b[i] for i in range(n)])
58
59     def __div__(self, scalar):
60         return NdVector([x / scalar for x in self.vec])
61
62     def vecLength(self):
63         return sqrt(self * self)
64
65     def vecLengthSq(self):
66         return (self * self)
67
68     def normalize(self):
69         len = self.length
70         self.vec = [x / len for x in self.vec]
71
72     def copy(self):
73         return NdVector(self.vec)
74
75     def __getitem__(self, i):
76         return self.vec[i]
77
78     def x(self):
79         return self.vec[0]
80
81     def y(self):
82         return self.vec[1]
83
84     def resize_2d(self):
85         return Vector((self.x, self.y))
86
87     length = property(vecLength)
88     lengthSq = property(vecLengthSq)
89     x = property(x)
90     y = property(y)
91
92
93 class dataPoint:
94     index = 0
95     # x,y1,y2,y3 coordinate of original point
96     co = NdVector((0, 0, 0, 0, 0))
97     #position according to parametric view of original data, [0,1] range
98     u = 0
99     #use this for anything
100     temp = 0
101
102     def __init__(self, index, co, u=0):
103         self.index = index
104         self.co = co
105         self.u = u
106
107
108 def autoloop_anim():
109     context = bpy.context
110     obj = context.active_object
111     fcurves = [x for x in obj.animation_data.action.fcurves if x.select]
112
113     data = []
114     end = len(fcurves[0].keyframe_points)
115
116     for i in range(1, end):
117         vec = []
118         for fcurve in fcurves:
119             vec.append(fcurve.evaluate(i))
120         data.append(NdVector(vec))
121
122     def comp(a, b):
123         return a * b
124
125     N = len(data)
126     Rxy = [0.0] * N
127     for i in range(N):
128         for j in range(i, min(i + N, N)):
129             Rxy[i] += comp(data[j], data[j - i])
130         for j in range(i):
131             Rxy[i] += comp(data[j], data[j - i + N])
132         Rxy[i] /= float(N)
133
134     def bestLocalMaximum(Rxy):
135         Rxyd = [Rxy[i] - Rxy[i - 1] for i in range(1, len(Rxy))]
136         maxs = []
137         for i in range(1, len(Rxyd) - 1):
138             a = Rxyd[i - 1]
139             b = Rxyd[i]
140             print(a, b)
141             #sign change (zerocrossing) at point i, denoting max point (only)
142             if (a >= 0 and b < 0) or (a < 0 and b >= 0):
143                 maxs.append((i, max(Rxy[i], Rxy[i - 1])))
144         return max(maxs, key=lambda x: x[1])[0]
145     flm = bestLocalMaximum(Rxy[0:int(len(Rxy))])
146
147     diff = []
148
149     for i in range(len(data) - flm):
150         diff.append((data[i] - data[i + flm]).lengthSq)
151
152     def lowerErrorSlice(diff, e):
153         #index, error at index
154         bestSlice = (0, 100000)
155         for i in range(e, len(diff) - e):
156             errorSlice = sum(diff[i - e:i + e + 1])
157             if errorSlice < bestSlice[1]:
158                 bestSlice = (i, errorSlice)
159         return bestSlice[0]
160
161     margin = 2
162
163     s = lowerErrorSlice(diff, margin)
164
165     print(flm, s)
166     loop = data[s:s + flm + margin]
167
168     #find *all* loops, s:s+flm, s+flm:s+2flm, etc...
169     #and interpolate between all
170     # to find "the perfect loop".
171     #Maybe before finding s? interp(i,i+flm,i+2flm)....
172     for i in range(1, margin + 1):
173         w1 = sqrt(float(i) / margin)
174         loop[-i] = (loop[-i] * w1) + (loop[0] * (1 - w1))
175
176     for curve in fcurves:
177         pts = curve.keyframe_points
178         for i in range(len(pts) - 1, -1, -1):
179             pts.remove(pts[i])
180
181     for c, curve in enumerate(fcurves):
182         pts = curve.keyframe_points
183         for i in range(len(loop)):
184             pts.insert(i + 1, loop[i][c])
185
186     context.scene.frame_end = flm + 1
187
188
189 def simplifyCurves(curveGroup, error, reparaError, maxIterations, group_mode):
190
191     def unitTangent(v, data_pts):
192         tang = NdVector((0, 0, 0, 0, 0))
193         if v != 0:
194             #If it's not the first point, we can calculate a leftside tangent
195             tang += data_pts[v].co - data_pts[v - 1].co
196         if v != len(data_pts) - 1:
197             #If it's not the last point, we can calculate a rightside tangent
198             tang += data_pts[v + 1].co - data_pts[v].co
199         tang.normalize()
200         return tang
201
202     #assign parametric u value for each point in original data
203     def chordLength(data_pts, s, e):
204         totalLength = 0
205         for pt in data_pts[s:e + 1]:
206             i = pt.index
207             if i == s:
208                 chordLength = 0
209             else:
210                 chordLength = (data_pts[i].co - data_pts[i - 1].co).length
211             totalLength += chordLength
212             pt.temp = totalLength
213         for pt in data_pts[s:e + 1]:
214             if totalLength == 0:
215                 print(s, e)
216             pt.u = (pt.temp / totalLength)
217
218     # get binomial coefficient, this function/table is only called with args
219     # (3,0),(3,1),(3,2),(3,3),(2,0),(2,1),(2,2)!
220     binomDict = {(3, 0): 1,
221     (3, 1): 3,
222     (3, 2): 3,
223     (3, 3): 1,
224     (2, 0): 1,
225     (2, 1): 2,
226     (2, 2): 1}
227     #value at pt t of a single bernstein Polynomial
228
229     def bernsteinPoly(n, i, t):
230         binomCoeff = binomDict[(n, i)]
231         return binomCoeff * pow(t, i) * pow(1 - t, n - i)
232
233     # fit a single cubic to data points in range [s(tart),e(nd)].
234     def fitSingleCubic(data_pts, s, e):
235
236         # A - matrix used for calculating C matrices for fitting
237         def A(i, j, s, e, t1, t2):
238             if j == 1:
239                 t = t1
240             if j == 2:
241                 t = t2
242             u = data_pts[i].u
243             return t * bernsteinPoly(3, j, u)
244
245         # X component, used for calculating X matrices for fitting
246         def xComponent(i, s, e):
247             di = data_pts[i].co
248             u = data_pts[i].u
249             v0 = data_pts[s].co
250             v3 = data_pts[e].co
251             a = v0 * bernsteinPoly(3, 0, u)
252             b = v0 * bernsteinPoly(3, 1, u)
253             c = v3 * bernsteinPoly(3, 2, u)
254             d = v3 * bernsteinPoly(3, 3, u)
255             return (di - (a + b + c + d))
256
257         t1 = unitTangent(s, data_pts)
258         t2 = unitTangent(e, data_pts)
259         c11 = sum([A(i, 1, s, e, t1, t2) * A(i, 1, s, e, t1, t2) for i in range(s, e + 1)])
260         c12 = sum([A(i, 1, s, e, t1, t2) * A(i, 2, s, e, t1, t2) for i in range(s, e + 1)])
261         c21 = c12
262         c22 = sum([A(i, 2, s, e, t1, t2) * A(i, 2, s, e, t1, t2) for i in range(s, e + 1)])
263
264         x1 = sum([xComponent(i, s, e) * A(i, 1, s, e, t1, t2) for i in range(s, e + 1)])
265         x2 = sum([xComponent(i, s, e) * A(i, 2, s, e, t1, t2) for i in range(s, e + 1)])
266
267         # calculate Determinate of the 3 matrices
268         det_cc = c11 * c22 - c21 * c12
269         det_cx = c11 * x2 - c12 * x1
270         det_xc = x1 * c22 - x2 * c12
271
272         # if matrix is not homogenous, fudge the data a bit
273         if det_cc == 0:
274             det_cc = 0.01
275
276         # alpha's are the correct offset for bezier handles
277         alpha0 = det_xc / det_cc   # offset from right (first) point
278         alpha1 = det_cx / det_cc   # offset from left (last) point
279
280         sRightHandle = data_pts[s].co.copy()
281         sTangent = t1 * abs(alpha0)
282         sRightHandle += sTangent  # position of first pt's handle
283         eLeftHandle = data_pts[e].co.copy()
284         eTangent = t2 * abs(alpha1)
285         eLeftHandle += eTangent  # position of last pt's handle.
286
287         # return a 4 member tuple representing the bezier
288         return (data_pts[s].co,
289               sRightHandle,
290               eLeftHandle,
291               data_pts[e].co)
292
293     # convert 2 given data points into a cubic bezier.
294     # handles are offset along the tangent at
295     # a 3rd of the length between the points.
296     def fitSingleCubic2Pts(data_pts, s, e):
297         alpha0 = alpha1 = (data_pts[s].co - data_pts[e].co).length / 3
298
299         sRightHandle = data_pts[s].co.copy()
300         sTangent = unitTangent(s, data_pts) * abs(alpha0)
301         sRightHandle += sTangent  # position of first pt's handle
302         eLeftHandle = data_pts[e].co.copy()
303         eTangent = unitTangent(e, data_pts) * abs(alpha1)
304         eLeftHandle += eTangent  # position of last pt's handle.
305
306         #return a 4 member tuple representing the bezier
307         return (data_pts[s].co,
308           sRightHandle,
309           eLeftHandle,
310           data_pts[e].co)
311
312     #evaluate bezier, represented by a 4 member tuple (pts) at point t.
313     def bezierEval(pts, t):
314         sumVec = NdVector((0, 0, 0, 0, 0))
315         for i in range(4):
316             sumVec += pts[i] * bernsteinPoly(3, i, t)
317         return sumVec
318
319     #calculate the highest error between bezier and original data
320     #returns the distance and the index of the point where max error occurs.
321     def maxErrorAmount(data_pts, bez, s, e):
322         maxError = 0
323         maxErrorPt = s
324         if e - s < 3:
325             return 0, None
326         for pt in data_pts[s:e + 1]:
327             bezVal = bezierEval(bez, pt.u)
328             normalize_error = pt.co.length
329             if normalize_error == 0:
330                 normalize_error = 1
331             tmpError = (pt.co - bezVal).length / normalize_error
332             if tmpError >= maxError:
333                 maxError = tmpError
334                 maxErrorPt = pt.index
335         return maxError, maxErrorPt
336
337     #calculated bezier derivative at point t.
338     #That is, tangent of point t.
339     def getBezDerivative(bez, t):
340         n = len(bez) - 1
341         sumVec = NdVector((0, 0, 0, 0, 0))
342         for i in range(n - 1):
343             sumVec += (bez[i + 1] - bez[i]) * bernsteinPoly(n - 1, i, t)
344         return sumVec
345
346     #use Newton-Raphson to find a better paramterization of datapoints,
347     #one that minimizes the distance (or error)
348     # between bezier and original data.
349     def newtonRaphson(data_pts, s, e, bez):
350         for pt in data_pts[s:e + 1]:
351             if pt.index == s:
352                 pt.u = 0
353             elif pt.index == e:
354                 pt.u = 1
355             else:
356                 u = pt.u
357                 qu = bezierEval(bez, pt.u)
358                 qud = getBezDerivative(bez, u)
359                 #we wish to minimize f(u),
360                 #the squared distance between curve and data
361                 fu = (qu - pt.co).length ** 2
362                 fud = (2 * (qu.x - pt.co.x) * (qud.x)) - (2 * (qu.y - pt.co.y) * (qud.y))
363                 if fud == 0:
364                     fu = 0
365                     fud = 1
366                 pt.u = pt.u - (fu / fud)
367
368     def createDataPts(curveGroup, group_mode):
369         data_pts = []
370         if group_mode:
371             print([x.data_path for x in curveGroup])
372             for i in range(len(curveGroup[0].keyframe_points)):
373                 x = curveGroup[0].keyframe_points[i].co.x
374                 y1 = curveGroup[0].keyframe_points[i].co.y
375                 y2 = curveGroup[1].keyframe_points[i].co.y
376                 y3 = curveGroup[2].keyframe_points[i].co.y
377                 y4 = 0
378                 if len(curveGroup) == 4:
379                     y4 = curveGroup[3].keyframe_points[i].co.y
380                 data_pts.append(dataPoint(i, NdVector((x, y1, y2, y3, y4))))
381         else:
382             for i in range(len(curveGroup.keyframe_points)):
383                 x = curveGroup.keyframe_points[i].co.x
384                 y1 = curveGroup.keyframe_points[i].co.y
385                 y2 = 0
386                 y3 = 0
387                 y4 = 0
388                 data_pts.append(dataPoint(i, NdVector((x, y1, y2, y3, y4))))
389         return data_pts
390
391     def fitCubic(data_pts, s, e):
392         # if there are less than 3 points, fit a single basic bezier
393         if e - s < 3:
394             bez = fitSingleCubic2Pts(data_pts, s, e)
395         else:
396             #if there are more, parameterize the points
397             # and fit a single cubic bezier
398             chordLength(data_pts, s, e)
399             bez = fitSingleCubic(data_pts, s, e)
400
401         #calculate max error and point where it occurs
402         maxError, maxErrorPt = maxErrorAmount(data_pts, bez, s, e)
403         #if error is small enough, reparameterization might be enough
404         if maxError < reparaError and maxError > error:
405             for i in range(maxIterations):
406                 newtonRaphson(data_pts, s, e, bez)
407                 if e - s < 3:
408                     bez = fitSingleCubic2Pts(data_pts, s, e)
409                 else:
410                     bez = fitSingleCubic(data_pts, s, e)
411
412         #recalculate max error and point where it occurs
413         maxError, maxErrorPt = maxErrorAmount(data_pts, bez, s, e)
414
415         #repara wasn't enough, we need 2 beziers for this range.
416         #Split the bezier at point of maximum error
417         if maxError > error:
418             fitCubic(data_pts, s, maxErrorPt)
419             fitCubic(data_pts, maxErrorPt, e)
420         else:
421             #error is small enough, return the beziers.
422             beziers.append(bez)
423             return
424
425     def createNewCurves(curveGroup, beziers, group_mode):
426         #remove all existing data points
427         if group_mode:
428             for fcurve in curveGroup:
429                 for i in range(len(fcurve.keyframe_points) - 1, 0, -1):
430                     fcurve.keyframe_points.remove(fcurve.keyframe_points[i])
431         else:
432             fcurve = curveGroup
433             for i in range(len(fcurve.keyframe_points) - 1, 0, -1):
434                 fcurve.keyframe_points.remove(fcurve.keyframe_points[i])
435
436         #insert the calculated beziers to blender data.\
437         if group_mode:
438             for fullbez in beziers:
439                 for i, fcurve in enumerate(curveGroup):
440                     bez = [Vector((vec[0], vec[i + 1])) for vec in fullbez]
441                     newKey = fcurve.keyframe_points.insert(frame=bez[0].x, value=bez[0].y)
442                     newKey.handle_right = (bez[1].x, bez[1].y)
443
444                     newKey = fcurve.keyframe_points.insert(frame=bez[3].x, value=bez[3].y)
445                     newKey.handle_left = (bez[2].x, bez[2].y)
446         else:
447             for bez in beziers:
448                 for vec in bez:
449                     vec.resize_2d()
450                 newKey = fcurve.keyframe_points.insert(frame=bez[0].x, value=bez[0].y)
451                 newKey.handle_right = (bez[1].x, bez[1].y)
452
453                 newKey = fcurve.keyframe_points.insert(frame=bez[3].x, value=bez[3].y)
454                 newKey.handle_left = (bez[2].x, bez[2].y)
455
456     # indices are detached from data point's frame (x) value and
457     # stored in the dataPoint object, represent a range
458
459     data_pts = createDataPts(curveGroup, group_mode)
460
461     s = 0  # start
462     e = len(data_pts) - 1  # end
463
464     beziers = []
465
466     #begin the recursive fitting algorithm.
467     fitCubic(data_pts, s, e)
468     #remove old Fcurves and insert the new ones
469     createNewCurves(curveGroup, beziers, group_mode)
470
471 #Main function of simplification
472 #sel_opt: either "sel" or "all" for which curves to effect
473 #error: maximum error allowed, in fraction (20% = 0.0020),
474 #i.e. divide by 10000 from percentage wanted.
475 #group_mode: boolean, to analyze each curve seperately or in groups,
476 #where group is all curves that effect the same property
477 #(e.g. a bone's x,y,z rotation)
478
479
480 def fcurves_simplify(context, obj, sel_opt="all", error=0.002, group_mode=True):
481     # main vars
482     fcurves = obj.animation_data.action.fcurves
483
484     if sel_opt == "sel":
485         sel_fcurves = [fcurve for fcurve in fcurves if fcurve.select]
486     else:
487         sel_fcurves = fcurves[:]
488
489     #Error threshold for Newton Raphson reparamatizing
490     reparaError = error * 32
491     maxIterations = 16
492
493     if group_mode:
494         fcurveDict = {}
495         #this loop sorts all the fcurves into groups of 3 or 4,
496         #based on their RNA Data path, which corresponds to
497         #which property they effect
498         for curve in sel_fcurves:
499             if curve.data_path in fcurveDict:  # if this bone has been added, append the curve to its list
500                 fcurveDict[curve.data_path].append(curve)
501             else:
502                 fcurveDict[curve.data_path] = [curve]  # new bone, add a new dict value with this first curve
503         fcurveGroups = fcurveDict.values()
504     else:
505         fcurveGroups = sel_fcurves
506
507     if error > 0.00000:
508         #simplify every selected curve.
509         totalt = 0
510         for i, fcurveGroup in enumerate(fcurveGroups):
511             print("Processing curve " + str(i + 1) + "/" + str(len(fcurveGroups)))
512             t = time.clock()
513             simplifyCurves(fcurveGroup, error, reparaError, maxIterations, group_mode)
514             t = time.clock() - t
515             print(str(t)[:5] + " seconds to process last curve")
516             totalt += t
517             print(str(totalt)[:5] + " seconds, total time elapsed")
518
519     return
520
521 # Implementation of non-linear median filter, with variable kernel size
522 # Double pass - one marks spikes, the other smooths one
523 # Expects sampled keyframes on everyframe
524
525
526 def denoise_median():
527     context = bpy.context
528     obj = context.active_object
529     fcurves = obj.animation_data.action.fcurves
530     medKernel = 1  # actually *2+1... since it this is offset
531     flagKernel = 4
532     highThres = (flagKernel * 2) - 1
533     lowThres = 0
534     for fcurve in fcurves:
535         orgPts = fcurve.keyframe_points[:]
536         flaggedFrames = []
537         # mark frames that are spikes by sorting a large kernel
538         for i in range(flagKernel, len(fcurve.keyframe_points) - flagKernel):
539             center = orgPts[i]
540             neighborhood = orgPts[i - flagKernel: i + flagKernel]
541             neighborhood.sort(key=lambda pt: pt.co[1])
542             weight = neighborhood.index(center)
543             if weight >= highThres or weight <= lowThres:
544                 flaggedFrames.append((i, center))
545         # clean marked frames with a simple median filter
546         # averages all frames in the kernel equally, except center which has no weight
547         for i, pt in flaggedFrames:
548             newValue = 0
549             sumWeights = 0
550             neighborhood = [neighpt.co[1] for neighpt in orgPts[i - medKernel: i + medKernel + 1] if neighpt != pt]
551             newValue = sum(neighborhood) / len(neighborhood)
552             pt.co[1] = newValue
553     return
554
555
556 def rotate_fix_armature(arm_data):
557     global_matrix = Matrix.Rotation(radians(90), 4, "X")
558     bpy.ops.object.mode_set(mode='EDIT', toggle=False)
559     #disconnect all bones for ease of global rotation
560     connectedBones = []
561     for bone in arm_data.edit_bones:
562         if bone.use_connect:
563             connectedBones.append(bone.name)
564             bone.use_connect = False
565
566     #rotate all the bones around their center
567     for bone in arm_data.edit_bones:
568         bone.transform(global_matrix)
569
570     #reconnect the bones
571     for bone in connectedBones:
572         arm_data.edit_bones[bone].use_connect = True
573     bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
574
575
576 def scale_fix_armature(performer_obj, enduser_obj):
577         perf_bones = performer_obj.data.bones
578         end_bones = enduser_obj.data.bones
579
580         def calculateBoundingRadius(bones):
581             center = Vector()
582             for bone in bones:
583                 center += bone.head_local
584             center /= len(bones)
585             radius = 0
586             for bone in bones:
587                 dist = (bone.head_local - center).length
588                 if dist > radius:
589                     radius = dist
590             return radius
591
592         perf_rad = calculateBoundingRadius(performer_obj.data.bones)
593         end_rad = calculateBoundingRadius(enduser_obj.data.bones)
594         #end_avg = enduser_obj.dimensions
595         factor = end_rad / perf_rad * 1.2
596         performer_obj.scale *= factor
597
598
599 def guessMapping(performer_obj, enduser_obj):
600         perf_bones = performer_obj.data.bones
601         end_bones = enduser_obj.data.bones
602
603         root = perf_bones[0]
604
605         def findBoneSide(bone):
606             if "Left" in bone:
607                 return "Left", bone.replace("Left", "").lower().replace(".", "")
608             if "Right" in bone:
609                 return "Right", bone.replace("Right", "").lower().replace(".", "")
610             if "L" in bone:
611                 return "Left", bone.replace("Left", "").lower().replace(".", "")
612             if "R" in bone:
613                 return "Right", bone.replace("Right", "").lower().replace(".", "")
614             return "", bone
615
616         def nameMatch(bone_a, bone_b):
617             # nameMatch - recieves two strings, returns 2 if they are relatively the same, 1 if they are the same but R and L and 0 if no match at all
618             side_a, noside_a = findBoneSide(bone_a)
619             side_b, noside_b = findBoneSide(bone_b)
620             if side_a == side_b:
621                 if noside_a in noside_b or noside_b in noside_a:
622                     return 2
623             else:
624                 if noside_a in noside_b or noside_b in noside_a:
625                     return 1
626             return 0
627
628         def guessSingleMapping(perf_bone):
629             possible_bones = [end_bones[0]]
630             while possible_bones:
631                 for end_bone in possible_bones:
632                     match = nameMatch(perf_bone.name, end_bone.name)
633                     if match == 2 and not perf_bone.map:
634                         perf_bone.map = end_bone.name
635                 newPossibleBones = []
636                 for end_bone in possible_bones:
637                     newPossibleBones += list(end_bone.children)
638                 possible_bones = newPossibleBones
639
640             for child in perf_bone.children:
641                 guessSingleMapping(child)
642
643         guessSingleMapping(root)
644
645
646 def limit_dof(context, performer_obj, enduser_obj):
647     limitDict = {}
648     perf_bones = [bone for bone in performer_obj.pose.bones if bone.bone.map]
649     c_frame = context.scene.frame_current
650     for bone in perf_bones:
651         limitDict[bone.bone.map] = [1000, 1000, 1000, -1000, -1000, -1000]
652     for t in range(context.scene.frame_start, context.scene.frame_end):
653         context.scene.frame_set(t)
654         for bone in perf_bones:
655             end_bone = enduser_obj.pose.bones[bone.bone.map]
656             bake_matrix = bone.matrix
657             rest_matrix = end_bone.bone.matrix_local
658
659             if end_bone.parent and end_bone.bone.use_inherit_rotation:
660                 srcParent = bone.parent
661                 parent_mat = srcParent.matrix
662                 parent_rest = end_bone.parent.bone.matrix_local
663                 parent_rest_inv = parent_rest.inverted()
664                 parent_mat_inv = parent_mat.inverted()
665                 bake_matrix = parent_mat_inv * bake_matrix
666                 rest_matrix = parent_rest_inv * rest_matrix
667
668             rest_matrix_inv = rest_matrix.inverted()
669             bake_matrix = rest_matrix_inv * bake_matrix
670
671             mat = bake_matrix
672             euler = mat.to_euler()
673             limitDict[bone.bone.map][0] = min(limitDict[bone.bone.map][0], euler.x)
674             limitDict[bone.bone.map][1] = min(limitDict[bone.bone.map][1], euler.y)
675             limitDict[bone.bone.map][2] = min(limitDict[bone.bone.map][2], euler.z)
676             limitDict[bone.bone.map][3] = max(limitDict[bone.bone.map][3], euler.x)
677             limitDict[bone.bone.map][4] = max(limitDict[bone.bone.map][4], euler.y)
678             limitDict[bone.bone.map][5] = max(limitDict[bone.bone.map][5], euler.z)
679     for bone in enduser_obj.pose.bones:
680         existingConstraint = [constraint for constraint in bone.constraints if constraint.name == "DOF Limitation"]
681         if existingConstraint:
682             bone.constraints.remove(existingConstraint[0])
683     end_bones = [bone for bone in enduser_obj.pose.bones if bone.name in limitDict.keys()]
684     for bone in end_bones:
685         #~ if not bone.is_in_ik_chain:
686         newCons = bone.constraints.new("LIMIT_ROTATION")
687         newCons.name = "DOF Limitation"
688         newCons.owner_space = "LOCAL"
689         newCons.min_x, newCons.min_y, newCons.min_z, newCons.max_x, newCons.max_y, newCons.max_z = limitDict[bone.name]
690         newCons.use_limit_x = True
691         newCons.use_limit_y = True
692         newCons.use_limit_z = True
693         #~ else:
694             #~ bone.ik_min_x, bone.ik_min_y, bone.ik_min_z, bone.ik_max_x, bone.ik_max_y, bone.ik_max_z = limitDict[bone.name]
695             #~ bone.use_ik_limit_x = True
696             #~ bone.use_ik_limit_y = True
697             #~ bone.use_ik_limit_z= True
698             #~ bone.ik_stiffness_x = 1/((limitDict[bone.name][3] - limitDict[bone.name][0])/(2*pi)))
699             #~ bone.ik_stiffness_y = 1/((limitDict[bone.name][4] - limitDict[bone.name][1])/(2*pi)))
700             #~ bone.ik_stiffness_z = 1/((limitDict[bone.name][5] - limitDict[bone.name][2])/(2*pi)))
701
702     context.scene.frame_set(c_frame)
703
704
705 def limit_dof_toggle_off(context, enduser_obj):
706     for bone in enduser_obj.pose.bones:
707         existingConstraint = [constraint for constraint in bone.constraints if constraint.name == "DOF Limitation"]
708         if existingConstraint:
709             bone.constraints.remove(existingConstraint[0])
710
711
712 def path_editing(context, stride_obj, path):
713     y_fcurve = [fcurve for fcurve in stride_obj.animation_data.action.fcurves if fcurve.data_path == "location"][1]
714     s, e = context.scene.frame_start, context.scene.frame_end  # y_fcurve.range()
715     s = int(s)
716     e = int(e)
717     y_s = y_fcurve.evaluate(s)
718     y_e = y_fcurve.evaluate(e)
719     direction = (y_e - y_s) / abs(y_e - y_s)
720     existing_cons = [constraint for constraint in stride_obj.constraints if constraint.type == "FOLLOW_PATH"]
721     for cons in existing_cons:
722         stride_obj.constraints.remove(cons)
723     path_cons = stride_obj.constraints.new("FOLLOW_PATH")
724     if direction < 0:
725         path_cons.forward_axis = "TRACK_NEGATIVE_Y"
726     else:
727         path_cons.forward_axis = "FORWARD_Y"
728     path_cons.target = path
729     path_cons.use_curve_follow = True
730     path.data.path_duration = e - s
731     try:
732         path.data.animation_data.action.fcurves
733     except AttributeError:
734         path.data.keyframe_insert("eval_time", frame=0)
735     eval_time_fcurve = [fcurve for fcurve in path.data.animation_data.action.fcurves if fcurve.data_path == "eval_time"]
736     eval_time_fcurve = eval_time_fcurve[0]
737     totalLength = 0
738     parameterization = {}
739     print("evaluating curve")
740     for t in range(s, e - 1):
741         if s == t:
742             chordLength = 0
743         else:
744             chordLength = (y_fcurve.evaluate(t) - y_fcurve.evaluate(t + 1))
745         totalLength += chordLength
746         parameterization[t] = totalLength
747     for t in range(s + 1, e - 1):
748         if totalLength == 0:
749             print("no forward motion")
750         parameterization[t] /= totalLength
751         parameterization[t] *= e - s
752     parameterization[e] = e - s
753     for t in parameterization.keys():
754         eval_time_fcurve.keyframe_points.insert(frame=t, value=parameterization[t])
755     y_fcurve.mute = True
756     print("finished path editing")
757
758
759 def anim_stitch(context, enduser_obj):
760     stitch_settings = enduser_obj.data.stitch_settings
761     action_1 = stitch_settings.first_action
762     action_2 = stitch_settings.second_action
763     if stitch_settings.stick_bone!="":
764         selected_bone = enduser_obj.pose.bones[stitch_settings.stick_bone]
765     else:
766         selected_bone = enduser_obj.pose.bones[0]
767     scene = context.scene
768     TrackNamesA = enduser_obj.data.mocapNLATracks[action_1]
769     TrackNamesB = enduser_obj.data.mocapNLATracks[action_2]
770     enduser_obj.data.active_mocap = action_1
771     anim_data = enduser_obj.animation_data
772     # add tracks for action 2
773     mocapAction = bpy.data.actions[TrackNamesB.base_track]
774     mocapTrack = anim_data.nla_tracks.new()
775     mocapTrack.name = TrackNamesB.base_track
776     mocapStrip = mocapTrack.strips.new(TrackNamesB.base_track, stitch_settings.blend_frame, mocapAction)
777     mocapStrip.extrapolation = "HOLD_FORWARD"
778     mocapStrip.blend_in = stitch_settings.blend_amount
779     mocapStrip.action_frame_start+=stitch_settings.second_offset
780     mocapStrip.action_frame_end+=stitch_settings.second_offset
781     constraintTrack = anim_data.nla_tracks.new()
782     constraintTrack.name = TrackNamesB.auto_fix_track
783     constraintAction = bpy.data.actions[TrackNamesB.auto_fix_track]
784     constraintStrip = constraintTrack.strips.new(TrackNamesB.auto_fix_track, stitch_settings.blend_frame, constraintAction)
785     constraintStrip.extrapolation = "HOLD_FORWARD"
786     constraintStrip.blend_in = stitch_settings.blend_amount
787     userTrack = anim_data.nla_tracks.new()
788     userTrack.name = TrackNamesB.manual_fix_track
789     userAction = bpy.data.actions[TrackNamesB.manual_fix_track]
790     userStrip = userTrack.strips.new(TrackNamesB.manual_fix_track, stitch_settings.blend_frame, userAction)
791     userStrip.extrapolation = "HOLD_FORWARD"
792     userStrip.blend_in = stitch_settings.blend_amount
793     #stride bone
794     if enduser_obj.parent:
795         if enduser_obj.parent.name == "stride_bone":
796             stride_bone = enduser_obj.parent
797             stride_anim_data = stride_bone.animation_data
798             stride_anim_data.use_nla = True
799             stride_anim_data.action = None
800             for track in stride_anim_data.nla_tracks:
801                 stride_anim_data.nla_tracks.remove(track)
802             actionATrack = stride_anim_data.nla_tracks.new()
803             actionATrack.name = TrackNamesA.stride_action
804             actionAStrip = actionATrack.strips.new(TrackNamesA.stride_action, 0, bpy.data.actions[TrackNamesA.stride_action])
805             actionAStrip.extrapolation = "NOTHING"
806             actionBTrack = stride_anim_data.nla_tracks.new()
807             actionBTrack.name = TrackNamesB.stride_action
808             actionBStrip = actionBTrack.strips.new(TrackNamesB.stride_action, stitch_settings.blend_frame, bpy.data.actions[TrackNamesB.stride_action])
809             actionBStrip.action_frame_start+=stitch_settings.second_offset
810             actionBStrip.action_frame_end+=stitch_settings.second_offset
811             actionBStrip.blend_in = stitch_settings.blend_amount
812             actionBStrip.extrapolation = "NOTHING"
813             #we need to change the stride_bone's action to add the offset
814             scene.frame_set(stitch_settings.blend_frame - 1)
815             desired_pos = (selected_bone.matrix.to_translation() * enduser_obj.matrix_world)
816             scene.frame_set(stitch_settings.blend_frame)
817             actual_pos = (selected_bone.matrix.to_translation() * enduser_obj.matrix_world)
818             offset = actual_pos - desired_pos
819             
820             for i,fcurve in enumerate([fcurve for fcurve in bpy.data.actions[TrackNamesB.stride_action].fcurves if fcurve.data_path=="location"]):
821                 print(offset[i],i,fcurve.array_index)
822                 for pt in fcurve.keyframe_points:
823                     pt.co.y-=offset[i]
824                     pt.handle_left.y-=offset[i]
825                     pt.handle_right.y-=offset[i]
826