1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
|
#!BPY
# -*- coding: latin-1 -*-
"""
Name: 'Motion Capture (.c3d)...'
Blender: 246
Group: 'Import'
Tooltip: 'Import a C3D Motion Capture file'
"""
__script__ = "C3D Motion Capture file import"
__author__ = " Jean-Baptiste PERIN, Roger D. Wickes (rogerwickes@yahoo.com)"
__version__ = "0.9"
__url__ = ["Communicate problems and errors, BlenderArtists.org, Python forum"]
__email__= ["rogerwickes@yahoo.com", "c3d script"]
__bpydoc__ = """\
c3d_import.py v0.8
Script loading Graphics Lab Motion Capture file,
Usage:<br>
- Run the script <br>
- Choose the file to open<br>
- Press Import C3D button<br>
Version History:
0.4: PERIN Released under Blender Artistic Licence
0.5: WICKES used marker names, fixed 2.45 depricated call
0.6: WICKES creates armature for each subject
0.7: WICKES constrains armature to follow the empties (markers). Verified for shake hands s
0.8: WICKES resolved DEC support issue
0.9: BARTON removed scene name change, whitespace edits. WICKES added IK layers
"""
#----------------------------------------------
# (c) Jean-Baptiste PERIN december 2005, released under Blender Artistic Licence
# for the Blender 2.40 Python Scripts Bundle.
#----------------------------------------------
######################################################
# This script imports a C3D file into blender.
# Loader is based on MATLAB C3D loader from
# Alan Morris, Toronto, October 1998
# Jaap Harlaar, Amsterdam, april 2002
######################################################
import string
import Blender
from Blender import *
import bpy
import struct
import BPyMessages
Vector= Blender.Mathutils.Vector
Euler= Blender.Mathutils.Euler
Matrix= Blender.Mathutils.Matrix
RotationMatrix = Blender.Mathutils.RotationMatrix
TranslationMatrix= Blender.Mathutils.TranslationMatrix
#=================
# Global Variables, Constants, Defaults, and Shorthand References
#=================
# set senstitivity for displaying debug/console messages. 0=few, 100=max, including clicks at major steps
# debug(num,string) to conditionally display status/info in console window
DEBUG=Blender.Get('rt')
# marker sets known in the world
HUMAN_CMU= "HumanRTKm.mkr" # The Human Real-Time capture marker set used by CMU
HUMAN_CMU2="HumanRT.mkr" # found in another file, seems same as others in that series
MARKER_SETS = [ HUMAN_CMU, HUMAN_CMU2 ] # marker sets that this program supports (can make an armature for)
XYZ_LIMIT= 10000 #max value for coordinates if in integer format
# what layers to put stuff on in scene. 1 is selected, so everything goes there
# selecting only layer 2 shows only the armature moving, 12 shows only the empties
LAYERS_ARMOB= [1,2]
LAYERS_MARKER=[1,12]
LAYERS_IK=[1,11]
IK_PREFIX="ik_" # prefix in empty name: ik_prefix+subject prefix+bone name
CLEAN=True # Should program ignore markers at (0,0,0) and beyond the outer limits?
scn = Blender.Scene.GetCurrent()
BCS=Blender.Constraint.Settings # shorthand dictionary - define with brace, reference with bracket
trackto={"+x":BCS.TRACKX, "+y":BCS.TRACKY, "+z":BCS.TRACKZ, "-x":BCS.TRACKNEGX, "-y":BCS.TRACKNEGY, "-z":BCS.TRACKNEGZ}
trackup={"x":BCS.UPX, "y":BCS.UPY, "z":BCS.UPZ}
#=============================#
# Classes
#=============================#
class Marker:
def __init__(self, x, y, z):
self.x=0.0
self.y=0.0
self.z=0.0
def __repr__(self): #report on self, as in if just printed
return str("[x = "+str(self.x) +" y = " + str(self.y)+" z = "+ str(self.z)+"]")
class ParameterGroup:
def __init__(self, nom, description, parameter):
self.name = nom
self.description = description
self.parameter = parameter
def __repr__(self):
return self.name, " ", self.description, " ", self.parameter
class Parameter:
def __init__(self, name, datatype, dim, data, description):
self.name = name
self.datatype = datatype
self.dim = dim
self.data = data
self.description = description
def __repr__(self):
return self.name, " ", self.description, " ", self.dim
class MyVector:
def __init__(self, fx,fy,fz):
self.x=fx
self.y=fy
self.z=fz
class Mybone:
"information structure for bone generation and posing"
def __init__(self, name,vec,par,head,tail,const):
self.name=name # name of this bone. must be unique within armature
self.vec=vec # edit bone vector it points
self.parent=par # name of parent bone to locate head and form a chain
self.headMark=head # list of 0+ markers where the head of this non-parented bone should be placed
self.tailMark=tail # list of 0+ markers where the tip should be placed
self.const=const # list of 0+ constraint tuples to control posing
self.head=MyVector(0,0,0) #T-pose location
self.tail=MyVector(0,0,0)
def __repr__(self):
return '[Mybone "%s"]' % self.name
#=============================#
# functions/modules
#=============================#
def error(str):
Draw.PupMenu('ERROR%t|'+str)
return
def status(str):
Draw.PupMenu('STATUS%t|'+str+"|Continue?")
return
def debug(num,msg): #use log4j or just console here.
if DEBUG >= num:
print 'debug:', (' '*num), msg
#TODO: if level 0, make a text file in Blender file to record major stuff
return
def names(ob): return ob.name
#########
# Cette fonction renvoie la liste des empties
# in :
# out : emp_list (List of Object) la liste des objets de type "Empty"
#########
def getEmpty(name):
obs = [ob for ob in scn.objects if ob.type=="Empty" and ob.name==name]
if len(obs)==0:
return None
elif len(obs)==1:
return obs[0]
else:
error("FATAL ERROR: %i empties %s in file" % (len(obs),ob[0]))
#########
# Cette fonction renvoie un empty
# in : objname : le nom de l'empty recherche
# out : myobj : l'empty cree ou retrouve
#########
def getOrCreateEmpty(objname):
myobj= getEmpty(objname)
if myobj==None:
myobj = scn.objects.new("Empty",objname)
debug(50,'Marker/Empty created %s' % myobj)
return myobj
def getOrCreateCurve(ipo, curvename):
"""
Retrieve or create a Blender Ipo Curve named C{curvename} in the C{ipo} Ipo
>>> import mylib
>>> lIpo = GetOrCreateIPO("Une IPO")
>>> laCurve = getOrCreateCurve(lIpo, "RotX")
Either an ipo curve named C{curvename} exists before the call then this curve is returned,
Or such a curve doesn't exist before the call .. then it is created into the c{ipo} Ipo and returned
@type ipo: Blender Ipo
@param ipo: the Ipo in which the curve must be retrieved or created.
@type curvename: string
@param curvename: name of the IPO.
@rtype: Blender Curve
@return: a Blender Curve named C{curvename} in the C{ipo} Ipo
"""
try:
mycurve = ipo.getCurve(curvename)
if mycurve != None:
pass
else:
mycurve = ipo.addCurve(curvename)
except:
mycurve = ipo.addCurve(curvename)
return mycurve
def eraseIPO (objectname):
object = Blender.Object.Get(objectname)
lIpo = object.getIpo()
if lIpo != None:
nbCurves = lIpo.getNcurves()
for i in range(nbCurves):
nbBezPoints = lIpo.getNBezPoints(i)
for j in range(nbBezPoints):
lIpo.delBezPoint(i)
def comp_loc(emptyNameList):
myloc=Vector(0,0,0)
for emName in emptyNameList:
myobj = Blender.Object.Get(emName)
for i in range(3):
myloc[i]= myloc[i]+(myobj.loc[i]/len(emptyNameList)) #take the average loc of all marks
return myloc
def comp_len(head, tail): # computes the length of a bone
headvec=comp_loc(head)
tailvec=comp_loc(tail)
netvec=headvec-tailvec
return netvec.length
def createHumanCMU(): # human bone structure, makes a node set for CMU MoCap Lab
# order of bones: "spine","chest","neck","head",...face toward you in front view
# pose constraints are tuples of (type,target,influence,other-as-needed)
# constraint stack order is important. for proper bone pointing and orinetation:
# IK, then TT +YZ in world space. then LR XZ to 0 in world space, this points the bone, twists it, but then
# limits the rotation to the sidebar enpty with the Z facing it, and Y pointing along the bone.
nodes=[] # bonename, vector, parent, head targets, tail targets, constraint list
for i in range(23): nodes.append(Mybone("name","vec","par",[],[],[]))
nodes[0]= Mybone("root", "-Y","",["RBWT", "LBWT"],["RFWT", "LFWT", "RBWT", "LBWT"],[("LOC","RBWT",1.0),("LOC","LBWT",0.5),("IK","RFWT",1.0),("IK","LFWT",0.5),("TT","RBWT",1,"+YZ"),("LR","XZ",1)])
nodes[1]= Mybone("spine","+Z","root",[],["STRN","T10"],[("IK","STRN",1.0),("IK","T10",0.5),("TT","STRN",1,"+YZ"),("LR","XZ",1)])
nodes[2]= Mybone("chest","+Z","spine",[],["CLAV","C7"],[("IK","CLAV",1.0),("IK","C7",0.5),("TT","CLAV",1,"+YZ"),("LR","XZ",1)])
nodes[3]= Mybone("neck", "+Z","chest",[],["RBHD","LBHD"],[("IK","RBHD",1.0),("IK","LBHD",0.5),("TT","LBHD",1,"+YZ"),("LR","XZ",1)])
nodes[4]= Mybone("head" ,"-Y","neck",[],["RFHD","LFHD"],[("IK","RFHD",1.0),("IK","LFHD",0.5),("TT","LFHD",1,"+YZ"),("LR","XZ",1)])
nodes[5]= Mybone("shoulder.R","-X","chest",[],["RSHO"],[("IK","RSHO",1.0)])
nodes[6]= Mybone("toparm.R", "-X","shoulder.R",[],["RELB"],[("IK","RELB",1.0),("TT","RUPA",1,"+YZ"),("LR","XZ",1)])
nodes[7]= Mybone("lowarm.R", "-X","toparm.R",[],["RWRA","RWRB"],[("IK","RWRA",1.0),("IK","RWRB",0.5),("TT","RFRM",1,"+YZ"),("LR","XZ",1)])
nodes[8]= Mybone("hand.R", "-X","lowarm.R",[],["RFIN"],[("IK","RFIN",1.0),("TT","RWRA",1,"+YZ"),("LR","XZ",1)]) #missing ,"RTHM"
nodes[9]= Mybone("hip.R", "-X","root",[],["RFWT","RBWT"],[("IK","RFWT",1.0),("IK","RBWT",0.5)])
nodes[10]=Mybone("topleg.R","-Z","hip.R",[],["RKNE"],[("IK","RKNE",1),("TT","RTHI",1,"+YZ"),("LR","XZ",1)])
nodes[11]=Mybone("lowleg.R","-Z","topleg.R",[],["RANK","RHEE"],[("IK","RHEE",1.0),("TT","RSHN",1,"+YZ"),("LR","XZ",1)])
nodes[12]=Mybone("foot.R", "-Y","lowleg.R",[],["RTOE","RMT5"],[("IK","RTOE",1.0),("IK","RMT5",0.2),("TT","RMT5",1,"+YZ")])
nodes[13]=Mybone("toes.R", "-Y","foot.R",[],["RTOE"],[("IK","RTOE",1.0)])
nodes[14]=Mybone("shoulder.L","+X","chest",[],["LSHO"],[("IK","LSHO",1.0)])
nodes[15]=Mybone("toparm.L", "+X","shoulder.L",[],["LELB"],[("IK","LELB",1.0),("TT","LUPA",1,"+YZ"),("LR","XZ",1)])
nodes[16]=Mybone("lowarm.L", "+X","toparm.L",[],["LWRA","LWRB"],[("IK","LWRA",1.0),("IK","LWRB",0.5),("TT","LFRM",1,"+YZ"),("LR","XZ",1)])
nodes[17]=Mybone("hand.L", "+X","lowarm.L",[],["LFIN"],[("IK","LFIN",1.0),("TT","RWRA",1,"+YZ"),("LR","XZ",1)]) #missing ,"LTHM"
nodes[18]=Mybone("hip.L", "+X","root",[],["LFWT","LBWT"],[("IK","LFWT",1.0),("IK","LBWT",0.5)])
nodes[19]=Mybone("topleg.L","-Z","hip.L",[],["LKNE"],[("IK","LKNE",1),("TT","LTHI",1,"+YZ"),("LR","XZ",1)])
nodes[20]=Mybone("lowleg.L","-Z","topleg.L",[],["LANK","LHEE"],[("IK","LHEE",1.0),("TT","LSHN",1,"+YZ"),("LR","XZ",1)])
nodes[21]=Mybone("foot.L", "-Y","lowleg.L",[],["LTOE","LMT5"],[("IK","LTOE",1.0),("IK","LMT5",0.2),("TT","LMT5",1,"+YZ"),("LR","XZ",1)])
nodes[22]=Mybone("toes.L", "-Y","foot.L",[],["LTOE"],[("IK","LTOE",1.0)])
return nodes
def createNodes(marker_set): # make a list of bone name, parent, edit head loc, edit tail loc, pose constraints
#ultimately, I want to read in an XML file here that specifies the node trees for various marker sets
if marker_set==HUMAN_CMU: nodes= createHumanCMU() #load up and verify the file has the CMU marker set
elif marker_set==HUMAN_CMU2: nodes= createHumanCMU()
else: nodes=[]
return nodes
def findEntry(item,list):
for i in range(len(list)):
if item==list[i]: break
debug(100,"findEtnry %s is %i in list of %i items" % (item,i,len(list)))
return i
def makeNodes(prefix, markerList, empties, marker_set): #make sure the file has the nodes selected
nodes= createNodes(marker_set) # list has generic marker names; replace them with the actual object names created
#each entry in markerlist has a corresponding entry in empties in the same order
errList=[]
for i in range(len(nodes)):
node= nodes[i]
debug(60,"Adapting node %s to prefix %s" % (node,prefix))
#replace generic head markers with actual empty names
for im in range(len(node.headMark)):
marker= node.headMark[im]
mark= prefix+marker
imn= findEntry(mark,markerList)
if imn < len(markerList):
debug(90,"Adapating head marker %s to %s" % (marker,empties[imn].name))
nodes[i].headMark[im]= empties[imn].name
else: errList.append([node.name,"head location",mark,node,2])
#replace generic tail markers with actual empty names
for im in range(len(node.tailMark)):
marker= node.tailMark[im]
mark= prefix+marker
imn= findEntry(mark,markerList)
if imn < len(markerList):
debug(90,"Adapating marker %s to %s" % (marker,empties[imn].name))
nodes[i].tailMark[im]= empties[imn].name
else: errList.append([node.name,"tail location",mark,node,2])
#replace generic constraint markers (if the constraint references a marker) with empty name
for im in range(len(node.const)):
const=node.const[im]
if const[0] in ("LOC","IK","TT"):
marker=const[1]
mark= prefix+marker
imn= findEntry(mark,markerList)
if imn < len(markerList):
debug(90,"Adapating %s constraint marker %s to %s" % (const[0],marker,empties[imn].name))
if const[0] in ("IK","LR","LOC"):
nodes[i].const[im]=(const[0], empties[imn].name, const[2])
else: nodes[i].const[im]=(const[0], empties[imn].name, const[2], const[3])
else: errList.append([node.name,const[0]+" constraint",mark,node,4])
if errList!=[]: #we have issues.
for err in errList:
debug(0,"Bone "+err[0]+" specifies "+err[2]+" as "+err[1]+"which was not specified in file.")
#need a popup here to ignore/cleanup node tree, or add the marker(?) or abort
usrOption= 1
if usrOption==0: #ignore this marker (remove it)
for node in nodes: #find the bone in error
if node.name==err[0]:
print "Before",node
if err[3] in range(2,3):
node[err[3]].remove(err[2]) #find the marker in error and remove it
elif err[3]==4: #find the constraint and remove it
for const in node.const:
if const[1]==err[2]: node.const.remove(const)
print "After",node
elif usrOption==1: #add these markers as static empties, and user will automate them later
#and the bones will be keyed to them, so it will all be good.
#file may have just mis-named the empty, or the location can be derived based on other markers
em= getOrCreateEmpty(err[2])
em.layers= LAYERS_MARKER
else: abort() #abend
if DEBUG==100: status("Nodes Updated")
return nodes #nodes may be updated
def makeBones(arm,nodes):
debug(20,"Making %i edit bones" % len(nodes))
for node in nodes:
bone= Blender.Armature.Editbone()
bone.name= node.name
arm.bones[bone.name]= bone #add it to the armature
debug(50,"Bone added: %s" % bone)
if bone.name <> node.name:
debug(0,"ERROR: duplicate node % name specified" % node.name)
node.name= bone.name #you may not get what you asked for
if node.parent!="": #parent
debug(60,"Bone parent: %s"%node.parent)
bone.parent= arm.bones[node.parent]
bone.options = [Armature.CONNECTED]
#compute head = average of the reference empties
if node.headMark==[]: # no head explicitly stated, must be tail of parent
for parnode in nodes:
if node.parent==parnode.name: break
node.headMark= parnode.tailMark
node.head= parnode.tail
else: node.head= comp_loc(node.headMark) #node head is specified, probably only for root.
bone.head= node.head
debug(60,"%s bone head: (%0.2f, %0.2f, %0.2f)" % (bone.name,bone.head.x, bone.head.y, bone.head.z))
mylen=comp_len(node.headMark,node.tailMark) # length of the bone as it was recorded for that person
# for our T position, compute the bone length, add it to the head vector component to get the tail
if node.vec[0]=="-": mylen=-mylen
debug(80,"Bone vector %s length %0.2f" %(node.vec,mylen))
node.tail= Vector(node.head)
myvec=node.vec[1].lower()
if myvec=="x": node.tail.x+=mylen
elif myvec=="y": node.tail.y+=mylen
elif myvec=="z": node.tail.z+=mylen
else:
debug(0,"%s %s %s %s" % (node.vec,myvec,node.vec[0],node.vec[1]))
error("ERROR IN BONE SPEC ")
bone.tail= node.tail
debug(60,"Bone tail: (%i,%i,%i)" %(bone.tail.x, bone.tail.y, bone.tail.z))
#Armature created in the T postion, but with bone lengths to match the marker set and subject
#when this is constrained to the markers, the recorded action will be relative to a know Rotation
#so that all recorded actions should be interchangeable. wooot!
#Only have to adjust starting object loc when matching up actions.
return #arm #updated
def makeConstLoc(pbone,const):
const_new= pbone.constraints.append(Constraint.Type.COPYLOC)
const_new.name = const[0]+"-"+const[1]
const_target=Blender.Object.Get(const[1])
const_new[BCS.TARGET]= const_target
const_new.influence = const[2]
return
def makeConstLimRot(pbone,const):
const_new= pbone.constraints.append(Constraint.Type.LIMITROT)
const_new.name = const[0]+"-"+const[1]
for axis in const[1]:
if axis.lower()=="x": const_new[BCS.LIMIT] |= BCS.LIMIT_XROT #set
if axis.lower()=="y": const_new[BCS.LIMIT] |= BCS.LIMIT_YROT #set
if axis.lower()=="z": const_new[BCS.LIMIT] |= BCS.LIMIT_ZROT #set
const_new[BCS.OWNERSPACE]= BCS.SPACE_LOCAL
const_new.influence = const[2]
# fyi, const[Constraint.Settings.LIMIT] &= ~Constraint.Settings.LIMIT_XROT #reset
return
def makeConstIK(prefix,pbone,const):
#Blender 246 only supports one IK Solver per bone, but we might want many,
# so we need to create a reference empty named after the bone
# that floats between the markers, so the bone can point to it as a singularity
myob= getOrCreateEmpty(IK_PREFIX+prefix+pbone.name)
myob.layers= LAYERS_IK
# note that this empty gets all the IK constraints added on as location constraints
myconst= myob.constraints.append(Constraint.Type.COPYLOC)
myconst.name=const[0]+"-"+const[1]
myconst[Constraint.Settings.TARGET]= Blender.Object.Get(const[1])
myconst.influence = const[2]
#point the bone once to the empty via IK
success=False
for myconst in pbone.constraints:
if myconst.type == Constraint.Type.IKSOLVER: success=True
if not(success): #add an IK constraint to the bone to point to the empty
#print pbone
myconst= pbone.constraints.append(Constraint.Type.IKSOLVER)
myconst.name = const[1]
myconst[BCS.TARGET]= myob
myconst.influence = const[2]
#const_new[Constraint.Settings.BONE]= ?
myconst[BCS.CHAINLEN]= 1
myconst[BCS.USETIP]= True
myconst[BCS.STRETCH]= False
return
def makeConstTT(pbone,const):
myconst= pbone.constraints.append(Constraint.Type.TRACKTO)
myconst.name=const[0]+"-"+const[1]
debug(70,"%s %s" % (myconst,const[3]))
myob= getEmpty(const[1])
if myob!= None:
myconst[BCS.TARGET]= myob
myconst.influence = const[2]
#const[3] is the Track and the thrird char is the Up indicator
myconst[BCS.TRACK]= trackto[const[3][0:2].lower()]
myconst[BCS.UP]=trackup[const[3][2].lower()]#up direction
myconst[BCS.OWNERSPACE]= BCS.SPACE_LOCAL
myconst[BCS.TARGETSPACE]= [BCS.SPACE_LOCAL]
if const[3][1]==const[3][2]: debug(0,"WARNING: Track To axis and up axis should not be the same. Constraint is INACTIVE")
else: #marker not found. could be missing from this file, or an error in node spec
error("TrackTo Constraint for %s |specifies unknown marker %s" % (pbone.name,const[1]))
return
def makePoses(prefix,arm_ob,nodes): # pose this armature object based on node requirements
#this is constraint-based posing, not hard-keyed posing.
#we do constraint-based first so that user can adjust the constraints, possibly smooth/tweak motion
# add additional bones or referneces/constraints, before baking to hard keyframes
pose= arm_ob.getPose()
debug(0,"Posing %s %s" % (arm_ob, pose))
for node in nodes:
debug(30, "examining %s" %node)
if len(node.const)>0: #constraints for this bone are desired
pbone = pose.bones[node.name]
debug(40,"Posing bone %s" %pbone)
for const in node.const:
debug(50,"Constraining %s by %s" %(pbone,const))
if const[0]=="LOC":makeConstLoc(pbone,const)
elif const[0]=="IK": makeConstIK(prefix,pbone,const)
elif const[0]=="LR": makeConstLimRot(pbone,const)
elif const[0]=="TT": makeConstTT(pbone,const)
else:
error("FATAL: constraint %s not supported" %const[0])
break
debug(10, "Posing complete. Cycling pose and edit mode")
pose.update()
return
def make_arm(subject,prefix,markerList, emptyList,marker_set):
debug(10,"**************************")
debug(00, "**** Making Armature for %s..." % subject)
debug(10, "**************************")
# copied from bvh import bvh_node_dict2armature; trying to use similar process for further integtration down the road
# Add the new armature,
nodes= makeNodes(prefix, markerList, emptyList, marker_set) #assume everyone in file uses the same mocap suit
# each person in the file may be different height, so each needs their own new armature to match marker location
## obs= Blender.Object.Get()
## success=False
## for ob in obs:
## if ob.name==subject:
## success=True
## if success:
## menu="Human Armature already exists for this subject."
## menu+="%t|Create another in this scene"
## menu+="%l|Start a new scene"
## menu+="%l|Use this armature"
## menusel= Draw.PupMenu(menu)
arm= Blender.Armature.New(subject) #make an armature.
debug(10,"Created Armature %s" % arm)
# Put us into editmode
arm.makeEditable()
arm.drawType = Armature.OCTAHEDRON
makeBones(arm,nodes)
scn = Blender.Scene.GetCurrent() #add it to the current scene. could create new scenes here as yaf
arm_ob= scn.objects.new(arm) #instance it in the scene. this is the new way for 2.46 to instance objects
arm_ob.name= subject #name it something like the person it represents
arm_ob.layers= LAYERS_ARMOB
debug(20,"Instanced Armature %s" % arm_ob)
arm.update() #exit editmode. Arm must be instanced as an object before you can save changes or pose it
Blender.Redraw() # show the world
if DEBUG==100: status("T-Bones made.")
makePoses(prefix,arm_ob,nodes) #constrain arm_ob with these markers
scn.update(1) #make everyone behave themselves in the scene, and respect the new constraints
return arm_ob
def setupAnim(StartFrame, EndFrame, VideoFrameRate):
debug(100, 'VideoFrameRate is %i' %VideoFrameRate)
if VideoFrameRate<1: VideoFrameRate=1
if VideoFrameRate>120: VideoFrameRate=120
# set up anim panel for them
context=scn.getRenderingContext()
context.startFrame(StartFrame)
context.endFrame(EndFrame)
context.framesPerSec(int(VideoFrameRate))
Blender.Set("curframe",StartFrame)
Blender.Redraw()
return
def makeCloud(Nmarkers,markerList,StartFrame,EndFrame,Markers):
debug(10, "**************************")
debug(00, "*** Making Cloud Formation")
debug(10, "**************************")
empties=[]
ipos=[]
curvesX=[]
curvesY=[]
curvesZ=[]
debug(0, "%i Markers (empty cloud) will be put on layers %s" % (Nmarkers,LAYERS_MARKER))
# Empty Cloud formation
for i in range(Nmarkers):
debug(100,"%i marker %s"%(i, markerList[i]))
emptyname = markerList[i] # rdw: to use meaningful names from Points parameter
em= getOrCreateEmpty(emptyname) #in this scene
em.layers= LAYERS_MARKER
#make a list of the actual empty
empties.append(em)
#assign it an ipo with the loc xyz curves
lipo = Ipo.New("Object",em.name)
ipos.append(lipo)
curvesX.append(getOrCreateCurve(ipos[i],'LocX'))
curvesY.append(getOrCreateCurve(ipos[i],'LocY'))
curvesZ.append(getOrCreateCurve(ipos[i],'LocZ'))
empties[i].setIpo(ipos[i])
debug(30,"Cloud of %i empties created." % len(empties))
NvideoFrames= EndFrame-StartFrame+1
debug(10, "**************************")
debug(00, "**** Calculating Marker Ipo Curves over %i Frames ..." % NvideoFrames)
debug(10, "**************************")
err= index=0 #number of errors, logical frame
for frame in range(StartFrame,EndFrame+1):
if index==0: start=sys.time()
elif index==100:
tmp=(NvideoFrames-100)*(sys.time()-start)/6000
debug(0,"%i minutes process time estimated" % tmp)
elif index >100: print index*100/(NvideoFrames-1),"% complete\r",
for i in range(Nmarkers):
if Markers[index][i].z < 0: Markers[index][i].z= -Markers[index][i].z
success=True
if CLEAN: #check for good data
# C3D marker decoding may have coordinates negative (improper sign bit decoding?)
myX= abs(Markers[index][i].x)
myY= abs(Markers[index][i].y)
myZ= Markers[index][i].z
if myX > 10000 or myY > 10000 or myZ > 10000: success=False
if myX <.01 and myY <.01 and myZ <.01: success=False # discontinuity in marker tracking (lost marker)
if success:
curvesX[i].append((frame, Markers[index][i].x)) #2.46 knot method
curvesY[i].append((frame, Markers[index][i].y))
curvesZ[i].append((frame, Markers[index][i].z))
if frame==StartFrame: debug(40, "%s loc frame %i: (%0.2f, %0.2f, %0.2f)" % (markerList[i],frame,Markers[index][i].x,Markers[index][i].y,Markers[index][i].z))
else:
err+=1 # some files have thousands...
#debug(30,"Point ignored for marker:%s frame %i: (%i, %i, %i)" % (markerList[i],frame,Markers[index][i].x,Markers[index][i].y,Markers[index][i].z))
index += 1
debug(70, "%i points ignored across all markers and frames. Recalculating..." % err)
for i in range(Nmarkers):
curvesX[i].Recalc()
curvesY[i].Recalc()
curvesZ[i].Recalc()
Blender.Set('curframe', StartFrame)
Blender.Redraw()
if DEBUG==100: status("Clound formed")
return empties
def getNumber(str, length):
if length==2: # unsigned short
return struct.unpack('H',str[0:2])[0], str[2:]
sum = 0
for i in range(length):
#sum = (sum << 8) + ord(str[i]) for big endian
sum = sum + ord(str[i])*(2**(8*i))
return sum, str[length:]
def unpackFloat(chunk,proctype):
#print proctype
myvar=chunk[0:4]
if proctype==2: #DEC-VAX
myvar=chunk[2:4]+chunk[0:2] #swap lo=hi word order pair
return struct.unpack('f',myvar[0:4])[0]
def getFloat(chunk,proctype):
return unpackFloat(chunk, proctype), chunk[4:]
def parseFloat(chunk,ptr,proctype):
return unpackFloat(chunk[ptr:ptr+4], proctype), ptr+4
def load_c3d(FullFileName):
# Input: FullFileName - file (including path) to be read
#
# Variable:
# Markers 3D-marker data [Nmarkers x NvideoFrames x Ndim(=3)]
# VideoFrameRate Frames/sec
# AnalogSignals Analog signals [Nsignals x NanalogSamples ]
# AnalogFrameRate Samples/sec
# Event Event(Nevents).time ..value ..name
# ParameterGroup ParameterGroup(Ngroups).Parameters(Nparameters).data ..etc.
# CameraInfo MarkerRelated CameraInfo [Nmarkers x NvideoFrames]
# ResidualError MarkerRelated ErrorInfo [Nmarkers x NvideoFrames]
Markers=[];
VideoFrameRate=120;
AnalogSignals=[];
AnalogFrameRate=0;
Event=[];
ParameterGroups=[];
CameraInfo=[];
ResidualError=[];
debug(10, "*********************")
debug(10, "**** Opening File ***")
debug(10, "*********************")
#ind=findstr(FullFileName,'\');
#if ind>0, FileName=FullFileName(ind(length(ind))+1:length(FullFileName)); else FileName=FullFileName; end
debug(0, "FileName = " + FullFileName)
fid=open(FullFileName,'rb'); # native format (PC-intel). ideasman says maybe rU
content = fid.read();
content_memory = content
#Header section
NrecordFirstParameterblock, content = getNumber(content,1) # Reading record number of parameter section
key, content = getNumber(content,1)
if key!=80:
error('File: does not comply to the C3D format')
fid.close()
return
#Paramter section
content = content[512*(NrecordFirstParameterblock-1)+1:] # first word ignored
#file format spec says that 3rd byte=NumberofParmaterRecords... but is ignored here.
proctype,content =getNumber(content,1)
proctype = proctype-83
proctypes= ["unknown","(INTEL-PC)","(DEC-VAX)","(MIPS-SUN/SGI)"]
if proctype in (1,2): debug(0, "Processor coding %s"%proctypes[proctype])
elif proctype==3: debug(0,"Program untested with %s"%proctypes[proctype])
else:
debug(0, "INVALID processor type %i"%proctype)
proctype=1
debug(0,"OVERRIDE processor type %i"%proctype)
#if proctype==2,
# fclose(fid);
# fid=fopen(FullFileName,'r','d'); % DEC VAX D floating point and VAX ordering
#end
debug(10, "***********************")
debug(00, "**** Reading Header ***")
debug(10, "***********************")
# ###############################################
# ## ##
# ## read header ##
# ## ##
# ###############################################
#%NrecordFirstParameterblock=fread(fid,1,'int8'); % Reading record number of parameter section
#%key1=fread(fid,1,'int8'); % key = 80;
content = content_memory
#fseek(fid,2,'bof');
content = content[2:]
#
Nmarkers, content=getNumber(content, 2)
NanalogSamplesPerVideoFrame, content = getNumber(content, 2)
StartFrame, content = getNumber(content, 2)
EndFrame, content = getNumber(content, 2)
MaxInterpolationGap, content = getNumber(content, 2)
Scale, content = getFloat(content,proctype)
NrecordDataBlock, content = getNumber(content, 2)
NanalogFramesPerVideoFrame, content = getNumber(content, 2)
if NanalogFramesPerVideoFrame > 0:
NanalogChannels=NanalogSamplesPerVideoFrame/NanalogFramesPerVideoFrame
else:
NanalogChannels=0
VideoFrameRate, content = getFloat(content,proctype)
AnalogFrameRate=VideoFrameRate*NanalogFramesPerVideoFrame
NvideoFrames = EndFrame - StartFrame + 1
debug(0, "Scale= %0.2f" %Scale)
debug(0, "NanalogFramesPerVideoFrame= %i" %NanalogFramesPerVideoFrame)
debug(0, "Video Frame Rate= %i" %VideoFrameRate)
debug(0, "AnalogFrame Rate= %i"%AnalogFrameRate)
debug(0, "# markers= %i" %Nmarkers)
debug(0, "StartFrame= %i" %StartFrame)
debug(0, "EndFrame= %i" %EndFrame)
debug(0, "# Video Frames= %i" %NvideoFrames)
if Scale>0:
debug(0, "Marker data is in integer format")
if Scale>(XYZ_LIMIT/32767):
Scale=XYZ_LIMIT/32767.0
debug(0, "OVERRIDE: Max coordinate is %i, Scale changed to %0.2f" % (XYZ_LIMIT,Scale))
else: debug(0, "Marker data is in floating point format")
if VideoFrameRate<1 or VideoFrameRate>120:
VideoFrameRate= 120
debug(0, "OVERRIDE Video Frame Rate= %i" %VideoFrameRate)
if proctype not in (1,2): # Intel, DEC are known good
debug(0, "OVERRIDE|Program not tested with this encoding. Set to Intel")
proctype= 1
debug(10, "***********************")
debug(10, "**** Reading Events ...")
debug(10, "***********************")
content = content_memory
content = content[298:] #bizarre .. ce devrait être 150 selon la doc rdw skips first 299 bytes?
EventIndicator, content = getNumber(content, 2)
EventTime=[]
EventValue=[]
EventName=[]
debug(0, "Event Indicator = %i" %EventIndicator)
if EventIndicator==12345: #rdw: somehow, this original code seems fishy, but I cannot deny it.
Nevents, content = getNumber(content, 2)
debug(0, "Nevents= %i" %Nevents)
content = content[2:]
if Nevents>0:
for i in range(Nevents):
letime, content = getFloat(content,proctype)
EventTime.append(letime)
content = content_memory
content = content[188*2:]
for i in range(Nevents):
lavalue, content = getNumber(content, 1)
EventValue.append(lavalue)
content = content_memory
content = content[198*2:]
for i in range(Nevents):
lenom = content[0:4]
content = content[4:]
EventName.append(lenom)
debug(00, "***************************")
debug(00, "**** Reading Parameters ...")
debug(10, "***************************")
subjects=[] # a name would be nice, but human will do
prefixes=[] # added on to mocap marker names, one for each subject
marker_subjects = [] # hopefully will be specified in the file and known to this program
markerList=[]
ParameterGroups = []
ParameterNumberIndex = []
content = content_memory
content = content[512*(NrecordFirstParameterblock-1):]
dat1, content = getNumber(content, 1)
key2, content = getNumber(content, 1)
NparameterRecords, content = getNumber(content, 1)
debug(100, "NparameterRecords=%i"%NparameterRecords)
proctype,content =getNumber(content,1)
proctype = proctype-83 # proctype: 1(INTEL-PC); 2(DEC-VAX); 3(MIPS-SUN/SGI)
for i in range(NparameterRecords):
leparam = ParameterGroup(None, None, [])
ParameterGroups.append(leparam)
ParameterNumberIndex.append(0)
#
Ncharacters, content = getNumber(content, 1)
if Ncharacters>=128:
Ncharacters = -(2**8)+(Ncharacters)
GroupNumber, content = getNumber(content, 1)
if GroupNumber>=128:
GroupNumber = -(2**8)+(GroupNumber)
debug(80,"GroupNumber = %i, Nchar=%i" %(GroupNumber,Ncharacters))
while Ncharacters > 0:
if GroupNumber<0:
GroupNumber=abs(GroupNumber)
GroupName = content[0:Ncharacters]
content = content[Ncharacters:]
#print "Group Number = ", GroupNumber
ParameterGroups[GroupNumber].name = GroupName
#print "ParameterGroupName =", GroupName
offset, content = getNumber(content, 2)
deschars, content = getNumber(content, 1)
GroupDescription = content[0:deschars]
content = content[deschars:]
ParameterGroups[GroupNumber].description = GroupDescription
#
ParameterNumberIndex[GroupNumber]=0
content = content[offset-3-deschars:]
else:
ParameterNumberIndex[GroupNumber]=ParameterNumberIndex[GroupNumber]+1
ParameterNumber=ParameterNumberIndex[GroupNumber]
#print "ParameterNumber=", ParameterNumber
ParameterGroups[GroupNumber].parameter.append(Parameter(None, None, [], [], None))
ParameterName = content[0:Ncharacters]
content = content[Ncharacters:]
#print "ParameterName = ",ParameterName
if len(ParameterName)>0:
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].name=ParameterName
offset, content = getNumber(content, 2)
filepos = len(content_memory)-len(content)
nextrec = filepos+offset-2
type, content=getNumber(content, 1)
if type>=128:
type = -(2**8)+type
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].type=type
dimnum, content=getNumber(content, 1)
if dimnum == 0:
datalength = abs(type)
else:
mult=1
dimension=[]
for j in range (dimnum):
ladim, content = getNumber(content, 1)
dimension.append(ladim)
mult=mult*dimension[j]
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].dim.append(dimension[j])
datalength = abs(type)*mult
#print "ParameterNumber = ", ParameterNumber, " Group Number = ", GroupNumber
if type==-1:
data = ""
wordlength=dimension[0]
if dimnum==2 and datalength>0:
for j in range(dimension[1]):
data=string.rstrip(content[0:wordlength])
content = content[wordlength:]
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data.append(data)
elif dimnum==1 and datalength>0:
data=content[0:wordlength]
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data.append(data) # ???
myParam=string.rstrip(ParameterName)
myGroup=string.rstrip(GroupName)
msg= "-%s-%s-" % (myGroup,myParam)
if myGroup == "POINT":
if myParam== "LABELS":
# named in form of subject:marker.
# the list "empties" is a corresponding list of actual empty object names that make up the cloud
markerList= ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
debug(0, "%sLABELS = %i %s" %(msg, len(markerList),markerList)) #list of logical markers from 0 to n corresponding to points
elif myParam== "LABELS2": #more labels
# named in form of subject:marker.
# the list "empties" is a corresponding list of actual empty object names that make up the cloud
momarkList= ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
markerList+=momarkList
debug(0, "%sLABELS2 = %i %s" %(msg, len(momarkList),momarkList)) #list of logical markers from 0 to n corresponding to points
else: debug(70, "%s UNUSED = %s" %(msg,ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data))
elif myGroup in ["SUBJECT", "SUBJECTS"]: #info about the actor
if myParam in ["NAME", "NAMES"]:
subjects= ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
debug(0, "%sNames of Subjects = %s" %(msg, subjects)) # might be useful in naming armatures
for i in range(len(subjects)):
subjects[i]=subjects[i].rstrip()
if subjects[i]=="": subjects[i]="Human"
elif myParam == "LABEL_PREFIXES":
prefixes = ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
debug(0, "%sMarker Prefixes = %s" %(msg, prefixes)) # to xlate marker name to that in file
for i in range(len(prefixes)):
prefixes[i]=prefixes[i].rstrip()
elif myParam== "MARKER_SETS":
marker_subjects= ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
debug(0, "%sMarker Set = %s"%(msg, marker_subjects)) # marker set that each subject was wearing
elif myParam== "MODEL_PARAM":
action= ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
debug(0, "%sModel Paramter = %s"%(msg,action)) # might be a good name for the blender scene
elif myParam== "LABELS":
# named in form of subject:marker.
# the list "empties" is a corresponding list of actual empty object names that make up the cloud
markerList= ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
debug(0, "%sLABELS = %i %s"%(msg, len(markerList),markerList)) #list of logical markers from 0 to n corresponding to points
else: debug(70, "%sUNUSED = %s"%(msg, ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data))
else:
debug(70, "%sUNUSED = %s"%(msg, ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data))
elif type == 1:
debug(100,"Block type %i is largely unsupported and untested."%type)
data = []
Nparameters=datalength/abs(type)
debug(100, "Nparameters=%i"%Nparameters)
for i in range(Nparameters):
ladata,content = getNumber(content, 1)
data.append(ladata)
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=data
#print ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
#print "type boolean"
elif type == 2 and datalength>0:
debug(100,"Block type %i is largely unsupported and untested."%type)
data = []
Nparameters=datalength/abs(type)
debug(100, "Nparameters=%i"%Nparameters)
for i in range(Nparameters):
ladata,content = getNumber(content, 2)
data.append(ladata)
#ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=data
if dimnum>1:
#???? print "arg je comprends pas"
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=data
#???ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=reshape(data,dimension)
else:
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=data
#print ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
#pass
#print "type integer"
elif type == 4 and datalength>0:
debug(100,"Block type %i is largely unsupported and untested."%type)
data = []
Nparameters=datalength/abs(type)
debug(100, "Nparameters=%i"%Nparameters)
for i in range(Nparameters):
ladata,content = getFloat(content,proctype)
data.append(ladata)
if dimnum>1:
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=data
#print "arg je comprends pas"
#???ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=reshape(data,dimension)
else:
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data=data
#print ParameterGroups[GroupNumber].parameter[ParameterNumber-1].data
else:
debug(100,"Block type %i is largely unsupported and untested."%type)
#print "error"
pass
deschars, content= getNumber(content, 1)
if deschars>0:
description = content[0:deschars]
content = content[deschars:]
ParameterGroups[GroupNumber].parameter[ParameterNumber-1].description=description
content = content_memory
content = content[nextrec:]
Ncharacters,content = getNumber(content, 1)
if Ncharacters>=128:
Ncharacters = -(2**8)+(Ncharacters)
GroupNumber,content = getNumber(content, 1)
if GroupNumber>=128:
GroupNumber = -(2**8)+(GroupNumber)
debug(80,"GroupNumber = %i, Nchar=%i" %(GroupNumber,Ncharacters))
debug(00, "***************************")
debug(00, "**** Examining Parameters ...")
debug(10, "***************************")
if len(subjects)==0: subjects=["Test"] #well, somebody got mocapped!
for i in range(0, len(subjects)-len(prefixes)): prefixes.append("")
for i in range(0, len(subjects)-len(marker_subjects)): marker_subjects.append(subjects[i])
#make a markerlist if they didn't
debug(0, "%i Markers specified, %i marker names supplied" %(Nmarkers,len(markerList)))
if len(markerList)==0:
debug(0, "File missing any POINT LABELS marker list. Making defaults")
#I guess just make cloud of empty.xxx
if len(markerList)<Nmarkers:
for i in range(len(markerList),Nmarkers): markerList.append("mark."+str(i))
#note that they may supply more markers than Nmarkers, extras are usually null or ignored
#an idea here to winnow down the marker List is to go through the nodes and see if there are markers
# in the list that are not used in constraining the armature, and discard them or set them debug(0,
# so that later on in processing we don't bother saving their location, possibly speeding up processing
# because we can just skip over their data block.
# put this on TODO list since it gets pretty complicated going throuch each marker set and all constraints etc.
## ###############################################
## ## ##
## ## Initalize Arrays and Allocate Memory
## ## ##
## ###############################################
## Get the coordinate and analog data
#
content = content_memory
content = content[(NrecordDataBlock-1)*512:]
debug(20,"Allocating memory for %i floats" %NvideoFrames*(Nmarkers*3+2))
for i in range (NvideoFrames):
Markers.append([])
ResidualError.append([])
CameraInfo.append([])
for j in range (Nmarkers):
Markers[i].append(Marker(0.0,0.0,0.0))
ResidualError[i].append(0)
CameraInfo[i].append(0)
#print Markers
#
#if Scale < 0
# for i=1:NvideoFrames
# for j=1:Nmarkers
# Markers(i,j,1:3)=fread(fid,3,'float32')';
# a=fix(fread(fid,1,'float32'));
# highbyte=fix(a/256);
# lowbyte=a-highbyte*256;
# CameraInfo(i,j)=highbyte;
# ResidualError(i,j)=lowbyte*abs(Scale);
# end
# waitbar(i/NvideoFrames)
# for j=1:NanalogFramesPerVideoFrame,
# AnalogSignals(j+NanalogFramesPerVideoFrame*(i-1),1:NanalogChannels)=...
# fread(fid,NanalogChannels,'int16')';
# end
# end
debug(10, "***************************")
debug(00, "**** Reading DataBlock of %i Frames...." % NvideoFrames)
debug(10, "***************************")
residuals= NanalogFramesPerVideoFrame*NanalogChannels*2
err=0 #keep track of errors or serious data issues
ptr_read = 0
if Scale < 0.0: # 3D Data - 4-byte Floating-point Format
for i in range (NvideoFrames):
if i==0: start=sys.time()
elif i==10:
tmp=(sys.time()-start)*NvideoFrames/600
debug(0,"%i minutes remaining..." % tmp)
else: print "%i percent complete. On Frame %i Points procesed: %i\r" % (i*100/NvideoFrames,i,i*Nmarkers),
for j in range (Nmarkers):
x,ptr_read = parseFloat(content, ptr_read, proctype)
y,ptr_read = parseFloat(content, ptr_read, proctype)
z,ptr_read = parseFloat(content, ptr_read, proctype)
myx= x * -Scale
myy= y * -Scale
myz= z * -Scale
if abs(myx)>XYZ_LIMIT or abs(myy)>XYZ_LIMIT or abs(myz)>XYZ_LIMIT:
err+=1
if err>100:
debug(0, "Warning: 100 data points for markers seem way out there")
debug(0, "data read: (%i, %i, %i)" %(x,y,z))
debug(0, "Consider revising Scale %0.2f" % Scale)
debug(0, "which now givs coordinates: (%i, %i, %i)" %(x*Scale,y*Scale,z*Scale))
err=-0
if abs(myx)>XYZ_LIMIT: myx= XYZ_LIMIT*myx/abs(myx) #preserve sign
if abs(myy)>XYZ_LIMIT: myy= XYZ_LIMIT*myy/abs(myy) #preserve sign
if abs(myz)>XYZ_LIMIT: myz= XYZ_LIMIT*myz/abs(myz) #preserve sign
Markers[i][j].x = myx
Markers[i][j].y = myy
Markers[i][j].z = myz
a,ptr_read = parseFloat(content, ptr_read, proctype)
a = int(a)
highbyte = int(a/256)
lowbyte=a-highbyte*256
CameraInfo[i][j] = highbyte
ResidualError[i][j] = lowbyte*abs(Scale)
#Monitor marker location to ensure data block is being parsed properly
if j==0: debug(90,"Frame %i loc of %s: (%i, %i, %i)" % (i,markerList[j],myx,myy,myz))
if i==0: debug(50, "Initial loc of %s: (%i, %i, %i)" % (markerList[j],myx,myy,myz))
ptr_read+=residuals #skip over the following
#for j in range (NanalogFramesPerVideoFrame):
# for k in range(NanalogChannels):
# val, content = getNumber(content, 2)
# AnalogSignals[j+NanalogFramesPerVideoFrame*(i)][k]=val #??? i-1
#else
# for i=1:NvideoFrames
# for j=1:Nmarkers
# Markers(i,j,1:3)=fread(fid,3,'int16')'.*Scale;
# ResidualError(i,j)=fread(fid,1,'int8');
# CameraInfo(i,j)=fread(fid,1,'int8');
# end
# waitbar(i/NvideoFrames)
# for j=1:NanalogFramesPerVideoFrame,
# AnalogSignals(j+NanalogFramesPerVideoFrame*(i-1),1:NanalogChannels)=...
# fread(fid,NanalogChannels,'int16')';
# end
# end
#end
else: #Scale is positive, but should be <1 to scale down, like 0.05
two16= -2**16
if len(content) < NvideoFrames*(Nmarkers*(6+2)+residuals):
error("%i bytes is not enough data for |%i frames|%i markers|%i residual" %(len(content),NvideoFrames,Nmarkers,residuals))
#Note: I really tried to optimize this loop, since it was taking hours to process
for i in range(NvideoFrames):
if i==0: start=sys.time()
elif i==10:
tmp=(sys.time()-start)*NvideoFrames/600
debug(0,"%i minutes remaining..." % tmp)
else: print "%i percent complete. On Frame %i Points procesed: %i\r" % (i*100/NvideoFrames,i,i*Nmarkers),
for j in range(Nmarkers):
#x, content = getNumber(content,2)
# this is old skool signed int, not but not a short.
x = ord(content[ptr_read+0]) + (ord(content[ptr_read+1])<<8)
if x>32768: x+=two16
y = ord(content[ptr_read+2]) + (ord(content[ptr_read+3])<<8)
if y>32768: y+=two16
z = ord(content[ptr_read+4]) + (ord(content[ptr_read+5])<<8)
if z>32768: z+=two16
##
## x = ord(content[ptr_read]) + ord(content[ptr_read+1])*(2**8)
## ptr_read+=2
## if x > 32768:
## x=-(2**16)+(x)
## #y, content = getNumber(content,2)
## y = ord(content[ptr_read]) + ord(content[ptr_read+1])*(2**8)
## ptr_read+=2
## if y > 32768:
## y=-(2**16)+(y)
## #z, content = getNumber(content,2)
## z = ord(content[ptr_read]) + ord(content[ptr_read+1])*(2**8)
## ptr_read+=2
## if z > 32768:
## z=-(2**16)+(z)
##
## print "(%i=%i, %i=%i, %i=%i)" %(x,myx,y,myy,z,myz)
# for integers, I changed Scale above to avoid getting impossible numbers
Markers[i][j].x = x*Scale
Markers[i][j].y = y*Scale
Markers[i][j].z = z*Scale
## ResidualError[i][j], content = getNumber(content, 1)
## CameraInfo[i][j], content = getNumber(content, 1)
#try to improve performance by:
ResidualError[i][j]= ord(content[ptr_read+6])
CameraInfo[i][j]= ord(content[ptr_read+7])
content= content[ptr_read+8:]
ptr_read=0
if j==0: debug(100,"Frame %i loc of %s: %s" % (i,markerList[j],Markers[i][j]))
if i==0: debug(50, "Initial loc of %s: (%s)" % (markerList[j],Markers[i][j]))
#for j in range (NanalogFramesPerVideoFrame):
# for k in range(NanalogChannels):
# val, content = getNumber(content, 2)
#AnalogSignals(j+NanalogFramesPerVideoFrame*(i-1),1:NanalogChannels)=val
ptr_read= residuals # skip over the above
print "\ndone with file."
fid.close()
cloud= makeCloud(Nmarkers,markerList,StartFrame,EndFrame,Markers)
setupAnim(StartFrame, EndFrame,VideoFrameRate)
debug(10, "**************************")
debug(00, "**** Making %i Armatures" % len(subjects))
debug(10, "**************************")
for i in range(len(subjects)):
marker_set= marker_subjects[i]
success=False
if len(marker_set)>0:
for trymark in MARKER_SETS:
if trymark[0:len(marker_set)]==marker_set:
marker_set=trymark
success=True
if success:
debug(0, "Armature for %s will be put on layers %s" % (subjects[i],LAYERS_ARMOB))
debug(0, " based on an markers beginning with %s" % prefixes[i])
ob= make_arm(subjects[i],prefixes[i],markerList,cloud,marker_set)
else:
debug(00, "Presently, this program can automatically create a constrained armature for marker sets %s" % MARKER_SETS)
debug(00, "%s uses an unknown marker set %s" % (subjects[i],marker_set))
debug(10, "Have a nice day! If you figure out an armature node system for this cloud, please add it to the program.")
debug(10, "**************************")
debug(00, "**** Conclusion")
minmax=[0,0,0,0,0,0]
for i in range(NvideoFrames):
for j in range(Nmarkers):
if minmax[0]>Markers[i][j].x: minmax[0]=Markers[i][j].x
if minmax[1]>Markers[i][j].y: minmax[1]=Markers[i][j].y
if minmax[2]>Markers[i][j].z: minmax[2]=Markers[i][j].z
if minmax[3]<Markers[i][j].x: minmax[3]=Markers[i][j].x
if minmax[4]<Markers[i][j].y: minmax[4]=Markers[i][j].y
if minmax[5]<Markers[i][j].z: minmax[5]=Markers[i][j].z
debug(0,"Markers move in 3D space from (%i,%i,%i) to (%i,%i,%i). "%(minmax[0],minmax[1],minmax[2],minmax[3],minmax[4],minmax[5]))
debug(0,"Set your 3D View Properties Clip End and zoom out your display.")
def my_callback(filename):
# processing options UI goes here, eventually
Window.WaitCursor(1)
t = sys.time()
load_c3d(filename)
# Timing the script is a good way to be aware on any speed hits when scripting
debug(0, '%s file processed in %.2f sec.' % (filename,sys.time()-t))
Window.WaitCursor(0)
def processFile():
# select file and pass a handle to the processor
Blender.Window.FileSelector(my_callback, "Import C3D") # makes a window a file selector and processes it
#processing contiues while file is being worked
def main():
# Display the GUI
# Run the function
processFile()
#Close files, display stats, cleanup, advice on next steps
# This lets you import the script without running it
if __name__ == '__main__':
debug(00, "------------------------------------")
debug(00, '%s %s script began at %.0f' % (__script__,__version__,sys.time()))
main()
|