Add files using upload-large-folder tool

msx_assets/object/004_sugar_box/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/006_mustard_bottle/material_0.mtl

@@ -0,0 +1,7 @@
+# https://github.com/mikedh/trimesh
+newmtl material_0
+Ka 0.40000000 0.40000000 0.40000000
+Kd 0.40000000 0.40000000 0.40000000
+Ks 0.40000000 0.40000000 0.40000000
+Ns 1.00000000
+map_Kd material_0.png

msx_assets/object/006_mustard_bottle/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/015_peach/material_0.mtl

@@ -0,0 +1,7 @@
+# https://github.com/mikedh/trimesh
+newmtl material_0
+Ka 0.40000000 0.40000000 0.40000000
+Kd 0.40000000 0.40000000 0.40000000
+Ks 0.40000000 0.40000000 0.40000000
+Ns 1.00000000
+map_Kd material_0.png

msx_assets/object/015_peach/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/018_plum/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/021_bleach_cleanser/collision.obj

@@ -0,0 +1,3090 @@
+o convex_0
+v 0.00290953 0.0260712 0.105665
+v 0.00287678 0.0260348 0.117146
+v 0.0097389 0.0243356 0.105665
+v -0.00279556 0.0260712 0.105665
+v 0.00572933 0.0231822 0.125709
+v 0.0066826 0.0241319 0.118099
+v -0.00282831 0.0260348 0.117146
+v 0.0123913 0.0212793 0.118099
+v 0.0115072 0.0232477 0.105665
+v -0.00288653 0.026053 0.105665
+v 0.00477969 0.022229 0.127612
+v 0.00715924 0.021756 0.127137
+v 0.00953515 0.0212793 0.126662
+v -0.00282831 0.0231822 0.125709
+v -0.00602287 0.0253544 0.105665
+v -0.00610655 0.0253216 0.105665
+v -0.00996331 0.0224691 0.124283
+v 0.0123913 0.0155706 0.126662
+v 0.0181001 0.0155706 0.106685
+v 0.0183038 0.0157744 0.105665
+v 0.0172123 0.017539 0.105665
+v 0.0143597 0.0203952 0.105665
+v 0.00572933 0.0203261 0.128563
+v -0.00377795 0.022229 0.127612
+v 0.00810887 0.0198531 0.128087
+v 0.0104884 0.0165239 0.127612
+v -0.0118153 0.0224691 0.105665
+v -0.00948668 0.022229 0.124759
+v -0.0123429 0.0212793 0.117146
+v -0.0151954 0.0184268 0.122856
+v -0.0117462 0.0203261 0.124996
+v 0.0109651 0.0141443 0.128087
+v 0.013341 0.0108151 0.127612
+v 0.0142942 0.0117648 0.125709
+v 0.0186094 0.0145518 0.105665
+v 0.00858551 0.0174735 0.128563
+v -0.00282831 0.0203261 0.128563
+v -0.0146023 0.0174735 0.124996
+v -0.0142785 0.0203952 0.105665
+v -0.0163852 0.0160472 0.124283
+v 0.0114381 0.0117648 0.128563
+v 0.013341 0.00511005 0.127612
+v 0.0142942 0.00605969 0.125709
+v 0.0171468 0.00891223 0.117146
+v 0.0186094 0.000285467 0.105665
+v -0.00889361 0.014621 0.12785
+v -0.00853704 0.0117648 0.128563
+v -0.0161487 0.014621 0.124759
+v -0.0142458 0.014621 0.125709
+v -0.0172002 0.0145518 0.105665
+v -0.0170983 0.014621 0.122856
+v 0.0114381 0.00605969 0.128563
+v 0.0172123 -0.00253433 0.105665
+v 0.0161971 0.00511005 0.119049
+v 0.0104884 -0.000598677 0.127612
+v 0.0171468 0.00605969 0.117146
+v -0.0113896 0.00605969 0.128563
+v -0.0161487 0.00320714 0.124759
+v -0.0151954 0.00605969 0.126662
+v -0.018561 0.0117648 0.105665
+v -0.0170983 0.00320714 0.122856
+v 0.00858551 0.000350959 0.128563
+v 0.0123913 -0.00345486 0.117146
+v 0.0143597 -0.00539052 0.105665
+v 0.0100118 -0.00178845 0.127137
+v 0.00858551 -0.00285815 0.12785
+v -0.0113896 0.000350959 0.128563
+v -0.0161487 0.00130423 0.123806
+v -0.015672 0.00178087 0.124996
+v -0.0151954 0.00320714 0.126662
+v -0.018561 0.00320714 0.105665
+v -0.0183427 0.00233391 0.105665
+v 0.00572933 -0.00250159 0.128563
+v 0.00715924 -0.004641 0.127137
+v 0.00858551 -0.00642747 0.117146
+v 0.0128643 -0.00607091 0.10716
+v 0.00858551 -0.00932368 0.105665
+v 0.00572933 -0.0044045 0.127612
+v -0.0132925 0.000350959 0.127612
+v -0.0128159 -0.00107531 0.12785
+v -0.00853704 -0.00250159 0.128563
+v -0.0151554 -0.0034112 0.105665
+v -0.0132925 -0.0044045 0.118099
+v -0.0123429 -0.00345486 0.124759
+v -0.0132925 -0.00155195 0.126662
+v -0.0149589 0.000350959 0.125353
+v 0.00287678 -0.00535413 0.125709
+v 0.00287678 -0.00821032 0.117146
+v 0.00430305 -0.00749718 0.118574
+v 0.00715924 -0.00749718 0.115723
+v 0.00572933 -0.00821032 0.114295
+v 2.4235e-05 -0.0110992 0.105665
+v -0.00853704 -0.0044045 0.127612
+v -0.00996331 -0.00392786 0.12785
+v -0.0118153 -0.00749718 0.105665
+v -0.0104399 -0.0044045 0.126662
+v -0.00853704 -0.00535413 0.125709
+v -0.00568086 -0.00821032 0.117146
+v -7.40032e-05 -0.0110992 0.105665
+v -0.00853704 -0.00880702 0.105665
+v -0.00758377 -0.00725704 0.118099
+v -0.00282831 -0.0106626 0.105665
+f 1 2 3
+f 1 3 9
+f 1 9 22
+f 1 22 21
+f 1 21 20
+f 1 20 35
+f 1 35 45
+f 1 45 53
+f 1 53 64
+f 1 64 77
+f 1 77 92
+f 1 92 99
+f 1 99 102
+f 1 102 100
+f 1 100 95
+f 1 95 82
+f 1 82 72
+f 1 72 71
+f 1 71 60
+f 1 60 50
+f 1 50 39
+f 1 39 27
+f 1 27 16
+f 1 16 15
+f 1 15 10
+f 1 10 4
+f 1 4 7
+f 1 7 2
+f 2 5 13
+f 2 13 6
+f 2 6 3
+f 2 7 14
+f 2 14 5
+f 3 6 8
+f 3 8 9
+f 4 10 7
+f 5 11 12
+f 5 12 13
+f 5 14 24
+f 5 24 11
+f 6 13 8
+f 7 10 15
+f 7 15 16
+f 7 16 17
+f 7 17 14
+f 8 18 19
+f 8 19 20
+f 8 20 21
+f 8 21 22
+f 8 22 9
+f 8 13 18
+f 11 23 25
+f 11 25 12
+f 11 24 37
+f 11 37 23
+f 12 25 13
+f 13 25 26
+f 13 26 18
+f 14 17 24
+f 16 27 17
+f 17 28 24
+f 17 27 29
+f 17 29 30
+f 17 30 31
+f 17 31 28
+f 18 32 33
+f 18 33 34
+f 18 34 19
+f 18 26 32
+f 19 34 35
+f 19 35 20
+f 23 36 25
+f 23 37 47
+f 23 47 57
+f 23 57 67
+f 23 67 81
+f 23 81 73
+f 23 73 62
+f 23 62 52
+f 23 52 41
+f 23 41 36
+f 24 28 31
+f 24 31 38
+f 24 38 37
+f 25 36 32
+f 25 32 26
+f 27 39 29
+f 29 39 30
+f 30 38 31
+f 30 39 40
+f 30 40 38
+f 32 41 33
+f 32 36 41
+f 33 41 52
+f 33 52 42
+f 33 42 43
+f 33 43 34
+f 34 43 56
+f 34 56 44
+f 34 44 35
+f 35 44 56
+f 35 56 45
+f 37 38 46
+f 37 46 47
+f 38 40 48
+f 38 48 49
+f 38 49 46
+f 39 50 40
+f 40 50 51
+f 40 51 48
+f 42 53 45
+f 42 45 54
+f 42 54 43
+f 42 52 62
+f 42 62 55
+f 42 55 53
+f 43 54 56
+f 45 56 54
+f 46 49 57
+f 46 57 47
+f 48 51 61
+f 48 61 58
+f 48 58 70
+f 48 70 59
+f 48 59 57
+f 48 57 49
+f 50 60 51
+f 51 60 71
+f 51 71 61
+f 53 63 64
+f 53 55 65
+f 53 65 63
+f 55 62 66
+f 55 66 65
+f 57 59 70
+f 57 70 79
+f 57 79 67
+f 58 68 69
+f 58 69 70
+f 58 61 68
+f 61 71 72
+f 61 72 68
+f 62 73 66
+f 63 65 74
+f 63 74 64
+f 64 74 75
+f 64 75 76
+f 64 76 77
+f 65 66 74
+f 66 73 78
+f 66 78 74
+f 67 79 80
+f 67 80 94
+f 67 94 81
+f 68 72 82
+f 68 82 83
+f 68 83 84
+f 68 84 85
+f 68 85 86
+f 68 86 69
+f 69 86 70
+f 70 86 80
+f 70 80 79
+f 73 81 93
+f 73 93 78
+f 74 78 87
+f 74 87 88
+f 74 88 89
+f 74 89 90
+f 74 90 77
+f 74 77 75
+f 75 77 76
+f 77 90 91
+f 77 91 92
+f 78 93 97
+f 78 97 87
+f 80 86 85
+f 80 85 96
+f 80 96 94
+f 81 94 93
+f 82 95 83
+f 83 95 96
+f 83 96 84
+f 84 96 85
+f 87 97 98
+f 87 98 88
+f 88 91 90
+f 88 90 89
+f 88 98 99
+f 88 99 92
+f 88 92 91
+f 93 94 96
+f 93 96 97
+f 95 100 98
+f 95 98 101
+f 95 101 96
+f 96 101 98
+f 96 98 97
+f 98 100 102
+f 98 102 99
+o convex_1
+v 0.0513991 0.00605665 -0.034114
+v 0.0513991 0.00320025 -0.034114
+v 0.0513991 0.00890634 -0.0455246
+v 0.0485438 0.0146191 0.00297761
+v 0.0485438 0.0117627 0.0143882
+v 0.0485438 0.00890634 0.0200935
+v 0.0513991 0.00035056 -0.036974
+v 0.0485438 0.00320025 0.0200935
+v 0.0485438 0.00035056 0.0172481
+v 0.0485438 0.0203252 -0.0455246
+v 0.0485438 0.0174688 -0.0112929
+v 0.0513991 0.00890634 -0.102607
+v 0.0456886 0.0174688 0.0315186
+v 0.0456886 0.0146191 0.0372239
+v 0.0456886 0.0117627 0.0429292
+v 0.0456886 0.00890634 0.045702
+v 0.0513991 -0.00249913 -0.0455246
+v 0.0485438 -0.00249913 0.0115428
+v 0.0485438 -0.00535553 0.00297761
+v 0.0456886 0.00310638 0.045702
+v 0.0456886 0.00035056 0.0429292
+v 0.0456886 -0.00535553 0.0315186
+v 0.0485438 0.0203252 -0.102607
+v 0.0456788 0.0260514 -0.102607
+v 0.0456886 0.0260313 -0.0883506
+v 0.0466371 0.0241337 -0.044581
+v 0.0466371 0.0212773 -0.0103493
+v 0.0437818 0.0241337 0.0153463
+v 0.0456886 0.0203252 0.0143882
+v 0.0513991 -0.00820522 -0.102607
+v 0.0437818 0.0212773 0.0324622
+v 0.0409265 0.0241337 0.0438873
+v 0.0428333 0.0203252 0.0429292
+v 0.0421684 0.0202313 0.045702
+v 0.0450139 0.0116689 0.045702
+v 0.0452094 0.0112867 0.04531
+v 0.0455908 0.00936899 0.045702
+v 0.0513991 -0.00535553 -0.0569497
+v 0.0456886 -0.00820522 0.0200935
+v 0.0485438 -0.00820522 -0.0112929
+v 0.0449943 8.59719e-06 0.045702
+v 0.0421195 -0.00856729 0.0429292
+v 0.0428333 -0.00820522 0.0400838
+v 0.0418848 -0.0101095 0.0400838
+v 0.0437818 -0.00915735 0.0315186
+v 0.0437818 -0.0120137 0.0200935
+v 0.0437818 0.0298398 -0.102607
+v 0.0437818 0.0298398 -0.0988031
+v 0.0437818 0.0269834 -0.0131946
+v 0.0409265 0.0269834 0.0239115
+v 0.04783 -0.0199661 -0.102607
+v 0.0513991 -0.00820522 -0.0826308
+v 0.0380712 0.0269834 0.045702
+v 0.0405647 0.0237717 0.045702
+v 0.0485438 -0.013918 -0.0512444
+v 0.0485438 -0.0110616 -0.0284233
+v 0.0466371 -0.0120137 -0.0112929
+v 0.0428039 -0.0054561 0.045702
+v 0.0409265 -0.0120137 0.0400838
+v 0.0418848 -0.00730002 0.045702
+v 0.0409558 -0.00914394 0.045702
+v 0.0437818 -0.0148701 0.00297761
+v 0.0418848 0.030792 -0.102607
+v 0.0418848 0.030792 -0.100719
+v 0.039978 0.0317441 -0.0997612
+v 0.0409265 0.0298398 -0.0502863
+v 0.0418848 0.0279356 -0.012251
+v 0.0371227 0.0288877 0.0229534
+v 0.0342675 0.0288877 0.045702
+v 0.0370347 0.0275064 0.045702
+v 0.039978 0.0288877 -0.0112929
+v 0.0478202 -0.0199862 -0.102607
+v 0.0485438 -0.0167677 -0.0769255
+v 0.0466371 -0.0177198 -0.0512444
+v 0.0466371 -0.0205762 -0.0769255
+v 0.0466371 -0.0148701 -0.0284233
+v 0.0408972 -0.0092244 0.045702
+v 0.0381103 -0.0120003 0.045702
+v 0.0385504 -0.0132006 0.0415065
+v 0.0385504 -0.0160569 0.0215307
+v 0.0409265 -0.0148701 0.0200935
+v 0.0437818 -0.0177198 -0.0198581
+v 0.0399976 0.0317374 -0.102607
+v 0.039978 0.0317441 -0.102607
+v 0.0314122 0.0345938 -0.102607
+v 0.0371227 0.0317441 -0.0512444
+v 0.0342675 0.0317441 -0.0284233
+v 0.0142903 0.0317441 0.045702
+v 0.0314122 0.0317441 -0.0112929
+v 0.0285569 0.0317441 0.000117704
+v 0.0447303 -0.0243848 -0.0940559
+v 0.0463926 -0.0221251 -0.102607
+v 0.0447303 -0.0215284 -0.0655149
+v 0.0437818 -0.0234326 -0.0740801
+v 0.0380419 -0.0120406 0.045702
+v 0.0362036 -0.0129592 0.045702
+v 0.0342675 -0.013918 0.045702
+v 0.0341794 -0.0139515 0.045702
+v 0.0371227 -0.013918 0.0400838
+v 0.0356951 -0.0160569 0.0300959
+v 0.0414056 -0.0189133 -0.0184354
+v 0.0414056 -0.0160569 0.00726021
+v 0.0371227 -0.0167677 0.0200935
+v 0.0414056 -0.0246194 -0.0726429
+v -0.0170982 0.0345938 -0.102607
+v 0.0257114 0.0345938 -0.0797854
+v -0.0228088 0.0317441 0.045702
+v 0.0228561 0.0345938 -0.0683603
+v 0.0200008 0.0345938 -0.0598096
+v 0.00857973 0.0345938 -0.034114
+v 0.00572445 0.0345938 -0.0312541
+v 3.34544e-05 0.0345938 -0.0255634
+v 0.0442609 -0.0246194 -0.0926187
+v 0.0385504 -0.0274758 -0.0926187
+v 0.0447303 -0.0243848 -0.102607
+v 0.0257114 -0.0167677 0.045702
+v 0.0299845 -0.0160569 0.0415065
+v 0.0285569 -0.0167677 0.0400838
+v 0.0342675 -0.0167677 0.0286587
+v 0.0314122 -0.031043 -0.0997612
+v 0.039978 -0.0253302 -0.0740801
+v -0.0285095 0.0317441 -0.102607
+v -0.0170982 0.0345938 -0.0883506
+v -0.0313648 0.0288877 0.0286587
+v -0.0332716 0.0279356 0.0286587
+v -0.0266125 0.0298398 0.045702
+v -0.0056771 0.0345938 -0.0284233
+v -0.00853238 0.0345938 -0.034114
+v -0.0113877 0.0345938 -0.0455246
+v -0.0142429 0.0345938 -0.062655
+v -0.0256543 0.0317441 0.00297761
+v -0.0342201 0.0288877 0.005823
+v 0.033319 -0.0300908 -0.0997612
+v 0.033319 -0.0300908 -0.102607
+v 0.0314122 -0.0196241 0.0086829
+v 0.00572445 -0.0196241 0.045702
+v 0.00857973 -0.0196241 0.0429292
+v 0.0200008 -0.0224805 0.00297761
+v 0.0171553 -0.033886 -0.102607
+v 0.0314122 -0.031043 -0.102607
+v -0.0370754 0.0288877 -0.102607
+v -0.0285095 0.0317441 -0.0455246
+v -0.0351686 0.0269834 0.0286587
+v -0.0361269 0.0279356 0.005823
+v -0.0323133 0.0269834 0.0400838
+v -0.026681 0.0297862 0.045702
+v -0.0370754 0.0288877 -0.0483845
+v -0.0143309 -0.0210054 0.045702
+v -0.0056771 -0.0224805 0.0286587
+v 0.00572445 -0.0253302 -0.00558759
+v 0.00857973 -0.0253302 -0.00844749
+v 0.0171456 -0.0253302 -0.0198581
+v 0.00572445 -0.0338927 -0.0940559
+v 0.011435 -0.0338927 -0.102607
+v 0.011435 -0.0281866 -0.0398193
+v 0.00286918 -0.0281866 -0.0312541
+v -0.0389626 0.0279423 -0.102607
+v -0.0389822 0.0279356 -0.0997612
+v -0.0380239 0.0241337 0.0200935
+v -0.0363616 0.0246098 0.0300959
+v -0.0352957 0.0231816 0.0400838
+v -0.0380239 0.0269834 0.005823
+v -0.0389822 0.0279356 -0.0483845
+v -0.0335063 0.0246098 0.0415065
+v -0.0320786 0.0246098 0.0443664
+v -0.0295265 0.0269566 0.045702
+v -0.0228968 -0.0196241 0.045702
+v -0.0256543 -0.0196241 0.0429292
+v -0.0256543 -0.0224805 0.0229534
+v -0.0228088 -0.0224805 0.0258133
+v -0.0199535 -0.0224805 0.0286587
+v -0.0170982 -0.0253302 0.000117704
+v -0.00282182 -0.0253302 0.000117704
+v 3.34544e-05 -0.0338927 -0.091196
+v -0.0170982 -0.0338927 -0.102607
+v -0.0399307 0.0260313 -0.102607
+v -0.0437344 0.0212773 -0.0940559
+v -0.0408792 0.0269834 -0.091196
+v -0.0392168 0.0217534 0.0215307
+v -0.0392168 0.0246098 0.00726021
+v -0.0363616 0.0217534 0.0386466
+v -0.0342592 0.0174688 0.045702
+v -0.0325089 0.0230877 0.045702
+v -0.0324111 0.0232755 0.045702
+v -0.0408792 0.0241337 -0.00844749
+v -0.0408792 0.0269834 -0.0483845
+v -0.0256543 -0.0190139 0.045702
+v -0.0260356 -0.0188664 0.045702
+v -0.027561 -0.018672 0.0438873
+v -0.0285095 -0.0196241 0.0372239
+v -0.0285095 -0.0224805 0.0172481
+v -0.0285095 -0.0253302 -0.0141528
+v -0.0228088 -0.0253302 -0.00558759
+v -0.0199535 -0.0253302 -0.00272768
+v -0.0113877 -0.0338927 -0.0940559
+v -0.0056771 -0.0338927 -0.091196
+v -0.0313648 -0.031043 -0.102607
+v -0.0142429 -0.0338927 -0.0969013
+v -0.0228088 -0.031043 -0.0740801
+v -0.0285095 -0.031043 -0.0854907
+v -0.0313648 -0.031043 -0.0940559
+v -0.0456412 0.0146191 -0.102607
+v -0.0456412 0.0174688 -0.0940559
+v -0.0427859 0.0231816 -0.091196
+v -0.0420721 0.0246098 -0.0412566
+v -0.0399307 0.0203252 0.0200935
+v -0.0399307 0.0174688 0.0258133
+v -0.0399307 0.0146191 0.0315186
+v -0.0370754 0.0203252 0.0372239
+v -0.0420721 0.018897 0.00726021
+v -0.0420721 0.0217534 -0.00701028
+v -0.0392168 0.0131909 0.0358012
+v -0.0363616 0.0160473 0.0415065
+v -0.034269 0.0173347 0.045702
+v -0.0270819 -0.0181959 0.045702
+v -0.0299372 -0.0181959 0.0407951
+v -0.0304163 -0.018672 0.038182
+v -0.0304163 -0.0215284 0.0181917
+v -0.0361269 -0.0215284 -0.00462945
+v -0.0342201 -0.0224805 -0.00558759
+v -0.0342201 -0.0253302 -0.034114
+v -0.0313648 -0.0253302 -0.022718
+v -0.0313648 -0.0281866 -0.0569497
+v -0.0228088 -0.0281866 -0.0398193
+v -0.0335258 -0.0301579 -0.102607
+v -0.0332716 -0.0300908 -0.0930978
+v -0.0390408 -0.0274959 -0.102607
+v -0.0342201 -0.0281866 -0.0683603
+v -0.0456412 -0.013918 -0.102607
+v -0.0484965 0.00035056 -0.0712202
+v -0.0456412 0.0174688 -0.0398193
+v -0.0449274 0.018897 -0.0383966
+v -0.0427859 0.0146191 0.0115428
+v -0.0427859 0.0174688 0.005823
+v -0.0399307 0.0117627 0.034364
+v -0.0427859 0.00890634 0.0172481
+v -0.0427859 0.00605665 0.0200935
+v -0.0427859 0.0203252 -0.00844749
+v -0.0389822 0.0117627 0.0362803
+v -0.034269 -0.00249913 0.045702
+v -0.0284704 -0.0168616 0.045702
+v -0.0286073 -0.0167275 0.045702
+v -0.0327925 -0.0153462 0.0407951
+v -0.0323133 -0.0177198 0.0362803
+v -0.0332716 -0.018672 0.0267569
+v -0.0351686 -0.0177198 0.0248552
+v -0.0380239 -0.0205762 -0.00654573
+v -0.0380239 -0.0234326 -0.0350722
+v -0.0361269 -0.0243848 -0.0331704
+v -0.0361269 -0.0272344 -0.0674167
+v -0.0420623 -0.021763 -0.102607
+v -0.0380239 -0.0262823 -0.0693185
+v -0.0408792 -0.0234326 -0.0607533
+v -0.0447514 -0.0160771 -0.102607
+v -0.0456412 -0.013918 -0.0598096
+v -0.0484965 0.00035056 -0.0683603
+v -0.0456412 0.0146191 -0.0198581
+v -0.0456412 0.0117627 -0.0112929
+v -0.0456412 0.00320025 -0.00272768
+v -0.0399307 0.00035056 0.034364
+v -0.0427859 0.00320025 0.0200935
+v -0.0389822 0.00035056 0.0362803
+v -0.0342397 -0.00535553 0.045702
+v -0.0361269 -0.00249913 0.0419855
+v -0.0299372 -0.0153462 0.045702
+v -0.0306021 -0.0142935 0.045702
+v -0.0308368 -0.013918 0.045702
+v -0.0327925 -0.0124898 0.0436405
+v -0.0356477 -0.0124898 0.0379352
+v -0.0332716 -0.0158223 0.038182
+v -0.0361269 -0.0158223 0.0267569
+v -0.0389822 -0.0158223 0.00964104
+v -0.0380239 -0.0177198 0.00772476
+v -0.0389822 -0.0215284 -0.0246197
+v -0.0389822 -0.018672 -0.00462945
+v -0.0408792 -0.0177198 -0.0150964
+v -0.0408792 -0.0205762 -0.0322123
+v -0.0389822 -0.0243848 -0.0531462
+v -0.0418277 -0.0215284 -0.0588515
+v -0.0446829 -0.0158223 -0.0588515
+v -0.0427859 -0.0167677 -0.0312541
+v -0.0456412 -0.0110616 -0.034114
+v -0.0456412 -0.00820522 -0.022718
+v -0.0456412 -0.00535553 -0.0141528
+v -0.0456412 -0.00249913 -0.00844749
+v -0.0427859 -0.00535553 0.0115428
+v -0.0427859 0.00035056 0.0172481
+v -0.0399307 -0.00249913 0.0315186
+v -0.0392168 -0.00249913 0.0347269
+v -0.0370754 -0.00249913 0.0400838
+v -0.0342201 -0.0054494 0.045702
+v -0.0363616 -0.0110616 0.0375868
+v -0.0335063 -0.00865446 0.045702
+v -0.0361269 -0.0129659 0.0353221
+v -0.0389822 -0.0129659 0.0181917
+v -0.0427859 -0.0110616 -0.00272768
+v -0.0418277 -0.0129659 -0.00178406
+v -0.0418277 -0.0158223 -0.0131946
+v -0.0418277 -0.018672 -0.0303105
+v -0.0427859 -0.013918 -0.0141528
+v -0.0427859 -0.00820522 0.005823
+v -0.0399307 -0.0110616 0.0172481
+v -0.0399307 -0.00535553 0.0286587
+v -0.0392168 -0.00535553 0.031867
+v -0.0370754 -0.0110616 0.034364
+f 103 104 109
+f 103 109 119
+f 103 119 140
+f 103 140 154
+f 103 154 132
+f 103 132 114
+f 103 114 105
+f 103 105 106
+f 103 106 107
+f 103 107 108
+f 103 108 110
+f 103 110 104
+f 104 110 111
+f 104 111 109
+f 105 112 113
+f 105 113 106
+f 105 114 125
+f 105 125 112
+f 106 113 115
+f 106 115 107
+f 107 115 116
+f 107 116 117
+f 107 117 108
+f 108 117 118
+f 108 118 122
+f 108 122 110
+f 109 111 120
+f 109 120 121
+f 109 121 119
+f 110 122 111
+f 111 122 123
+f 111 123 124
+f 111 124 120
+f 112 125 126
+f 112 126 127
+f 112 127 128
+f 112 128 129
+f 112 129 113
+f 113 129 130
+f 113 130 131
+f 113 131 115
+f 114 132 153
+f 114 153 174
+f 114 174 194
+f 114 194 217
+f 114 217 236
+f 114 236 242
+f 114 242 241
+f 114 241 256
+f 114 256 277
+f 114 277 299
+f 114 299 327
+f 114 327 329
+f 114 329 353
+f 114 353 356
+f 114 356 331
+f 114 331 304
+f 114 304 278
+f 114 278 259
+f 114 259 243
+f 114 243 224
+f 114 224 207
+f 114 207 187
+f 114 187 186
+f 114 186 185
+f 114 185 165
+f 114 165 149
+f 114 149 126
+f 114 126 125
+f 115 133 134
+f 115 134 135
+f 115 135 116
+f 115 131 130
+f 115 130 133
+f 116 135 117
+f 117 135 136
+f 117 136 137
+f 117 137 138
+f 117 138 139
+f 117 139 118
+f 118 139 137
+f 118 137 136
+f 118 136 156
+f 118 156 155
+f 118 155 172
+f 118 172 171
+f 118 171 190
+f 118 190 209
+f 118 209 228
+f 118 228 248
+f 118 248 268
+f 118 268 286
+f 118 286 285
+f 118 285 284
+f 118 284 316
+f 118 316 342
+f 118 342 365
+f 118 365 393
+f 118 393 395
+f 118 395 369
+f 118 369 368
+f 118 368 367
+f 118 367 344
+f 118 344 343
+f 118 343 317
+f 118 317 290
+f 118 290 289
+f 118 289 269
+f 118 269 250
+f 118 250 238
+f 118 238 218
+f 118 218 200
+f 118 200 199
+f 118 199 198
+f 118 198 197
+f 118 197 180
+f 118 180 179
+f 118 179 163
+f 118 163 162
+f 118 162 160
+f 118 160 143
+f 118 143 122
+f 119 121 140
+f 120 124 121
+f 121 124 141
+f 121 141 142
+f 121 142 140
+f 122 143 123
+f 123 143 144
+f 123 144 124
+f 124 144 145
+f 124 145 146
+f 124 146 147
+f 124 147 148
+f 124 148 141
+f 126 149 150
+f 126 150 127
+f 127 150 128
+f 128 150 151
+f 128 151 129
+f 129 151 130
+f 130 152 134
+f 130 134 133
+f 130 151 152
+f 132 154 153
+f 134 155 156
+f 134 156 136
+f 134 136 135
+f 134 152 155
+f 137 139 138
+f 140 157 175
+f 140 175 154
+f 140 142 158
+f 140 158 157
+f 141 148 159
+f 141 159 142
+f 142 159 178
+f 142 178 158
+f 143 160 144
+f 144 161 146
+f 144 146 145
+f 144 160 162
+f 144 162 163
+f 144 163 161
+f 146 161 147
+f 147 161 148
+f 148 161 164
+f 148 164 159
+f 149 165 166
+f 149 166 150
+f 150 166 167
+f 150 167 188
+f 150 188 168
+f 150 168 151
+f 151 169 152
+f 151 168 169
+f 152 170 171
+f 152 171 172
+f 152 172 155
+f 152 169 173
+f 152 173 170
+f 153 154 175
+f 153 175 174
+f 157 176 177
+f 157 177 175
+f 157 158 178
+f 157 178 176
+f 159 164 178
+f 161 163 179
+f 161 179 180
+f 161 180 181
+f 161 181 182
+f 161 182 183
+f 161 183 164
+f 164 184 176
+f 164 176 178
+f 164 183 184
+f 165 185 166
+f 166 185 167
+f 167 185 186
+f 167 186 187
+f 167 187 188
+f 168 188 173
+f 168 173 169
+f 170 173 188
+f 170 188 189
+f 170 189 171
+f 171 189 191
+f 171 191 192
+f 171 192 190
+f 174 193 194
+f 174 175 177
+f 174 177 193
+f 176 184 177
+f 177 195 196
+f 177 196 193
+f 177 184 195
+f 180 197 181
+f 181 197 198
+f 181 198 199
+f 181 199 200
+f 181 200 201
+f 181 201 202
+f 181 202 182
+f 182 203 204
+f 182 204 183
+f 182 202 221
+f 182 221 205
+f 182 205 223
+f 182 223 206
+f 182 206 203
+f 183 204 184
+f 184 204 203
+f 184 203 196
+f 184 196 195
+f 187 207 225
+f 187 225 232
+f 187 232 231
+f 187 231 230
+f 187 230 229
+f 187 229 214
+f 187 214 213
+f 187 213 212
+f 187 212 211
+f 187 211 210
+f 187 210 208
+f 187 208 191
+f 187 191 189
+f 187 189 188
+f 190 192 210
+f 190 210 211
+f 190 211 212
+f 190 212 213
+f 190 213 214
+f 190 214 209
+f 191 208 210
+f 191 210 192
+f 193 215 216
+f 193 216 217
+f 193 217 194
+f 193 196 215
+f 196 206 215
+f 196 203 206
+f 200 218 219
+f 200 219 201
+f 201 219 202
+f 202 219 220
+f 202 220 221
+f 205 221 222
+f 205 222 223
+f 206 223 222
+f 206 222 216
+f 206 216 215
+f 207 224 244
+f 207 244 225
+f 209 226 227
+f 209 227 228
+f 209 214 229
+f 209 229 230
+f 209 230 231
+f 209 231 232
+f 209 232 225
+f 209 225 233
+f 209 233 234
+f 209 234 226
+f 216 222 235
+f 216 235 236
+f 216 236 217
+f 218 237 220
+f 218 220 219
+f 218 238 239
+f 218 239 240
+f 218 240 237
+f 220 237 221
+f 221 237 222
+f 222 241 242
+f 222 242 236
+f 222 236 235
+f 222 237 240
+f 222 240 241
+f 224 243 249
+f 224 249 244
+f 225 244 233
+f 226 234 246
+f 226 246 227
+f 227 245 228
+f 227 246 264
+f 227 264 245
+f 228 247 248
+f 228 245 247
+f 233 244 234
+f 234 244 249
+f 234 249 265
+f 234 265 246
+f 238 250 251
+f 238 251 252
+f 238 252 239
+f 239 252 253
+f 239 253 240
+f 240 253 254
+f 240 254 241
+f 241 255 256
+f 241 254 257
+f 241 257 258
+f 241 258 255
+f 243 259 260
+f 243 260 265
+f 243 265 249
+f 245 261 262
+f 245 262 263
+f 245 263 247
+f 245 264 261
+f 246 265 288
+f 246 288 264
+f 247 263 266
+f 247 266 267
+f 247 267 268
+f 247 268 248
+f 250 269 270
+f 250 270 271
+f 250 271 272
+f 250 272 273
+f 250 273 274
+f 250 274 275
+f 250 275 251
+f 251 275 252
+f 252 275 258
+f 252 258 257
+f 252 257 253
+f 253 257 254
+f 255 276 298
+f 255 298 297
+f 255 297 300
+f 255 300 277
+f 255 277 256
+f 255 258 276
+f 258 275 276
+f 259 278 279
+f 259 279 280
+f 259 280 260
+f 260 280 288
+f 260 288 265
+f 261 281 262
+f 261 264 282
+f 261 282 281
+f 262 283 263
+f 262 281 283
+f 263 283 284
+f 263 284 285
+f 263 285 286
+f 263 286 267
+f 263 267 266
+f 264 287 282
+f 264 288 287
+f 267 286 268
+f 269 289 270
+f 270 289 290
+f 270 290 291
+f 270 291 319
+f 270 319 292
+f 270 292 293
+f 270 293 271
+f 271 293 294
+f 271 294 295
+f 271 295 272
+f 272 295 296
+f 272 296 274
+f 272 274 273
+f 274 296 300
+f 274 300 297
+f 274 297 298
+f 274 298 276
+f 274 276 275
+f 277 300 301
+f 277 301 302
+f 277 302 303
+f 277 303 299
+f 278 304 305
+f 278 305 279
+f 279 305 306
+f 279 306 280
+f 280 306 307
+f 280 307 288
+f 281 308 309
+f 281 309 310
+f 281 310 311
+f 281 311 283
+f 281 282 313
+f 281 313 312
+f 281 312 336
+f 281 336 308
+f 282 287 313
+f 283 311 314
+f 283 314 315
+f 283 315 284
+f 284 315 316
+f 287 288 307
+f 287 307 313
+f 290 317 291
+f 291 317 318
+f 291 318 319
+f 292 319 293
+f 293 319 320
+f 293 320 321
+f 293 321 322
+f 293 322 323
+f 293 323 324
+f 293 324 294
+f 294 324 325
+f 294 325 302
+f 294 302 301
+f 294 301 326
+f 294 326 295
+f 295 326 300
+f 295 300 296
+f 299 303 327
+f 300 326 301
+f 302 325 303
+f 303 328 329
+f 303 329 327
+f 303 325 330
+f 303 330 328
+f 304 331 332
+f 304 332 305
+f 305 332 358
+f 305 358 333
+f 305 333 334
+f 305 334 307
+f 305 307 306
+f 307 334 313
+f 308 335 309
+f 308 336 335
+f 309 335 310
+f 310 337 314
+f 310 314 311
+f 310 335 338
+f 310 338 339
+f 310 339 337
+f 312 313 340
+f 312 340 336
+f 313 334 333
+f 313 333 340
+f 314 337 341
+f 314 341 316
+f 314 316 315
+f 316 341 364
+f 316 364 342
+f 317 343 318
+f 318 343 344
+f 318 344 345
+f 318 345 346
+f 318 346 319
+f 319 346 348
+f 319 348 347
+f 319 347 321
+f 319 321 320
+f 321 347 348
+f 321 348 349
+f 321 349 350
+f 321 350 351
+f 321 351 322
+f 322 351 323
+f 323 351 330
+f 323 330 325
+f 323 325 324
+f 328 330 352
+f 328 352 329
+f 329 352 354
+f 329 354 355
+f 329 355 353
+f 330 351 352
+f 331 356 357
+f 331 357 358
+f 331 358 332
+f 333 358 359
+f 333 359 340
+f 335 336 360
+f 335 360 361
+f 335 361 338
+f 336 340 359
+f 336 359 360
+f 337 339 363
+f 337 363 362
+f 337 362 364
+f 337 364 341
+f 338 361 339
+f 339 361 363
+f 342 364 366
+f 342 366 365
+f 344 367 345
+f 345 367 368
+f 345 368 369
+f 345 369 370
+f 345 370 371
+f 345 371 396
+f 345 396 372
+f 345 372 346
+f 346 372 373
+f 346 373 348
+f 348 373 374
+f 348 374 375
+f 348 375 349
+f 349 376 380
+f 349 380 350
+f 349 375 374
+f 349 374 377
+f 349 377 378
+f 349 378 379
+f 349 379 376
+f 350 380 351
+f 351 380 352
+f 352 380 354
+f 353 355 381
+f 353 381 382
+f 353 382 357
+f 353 357 356
+f 354 380 355
+f 355 380 379
+f 355 379 401
+f 355 401 381
+f 357 382 383
+f 357 383 384
+f 357 384 358
+f 358 361 360
+f 358 360 359
+f 358 384 385
+f 358 385 386
+f 358 386 387
+f 358 387 361
+f 361 387 388
+f 361 388 389
+f 361 389 363
+f 362 363 389
+f 362 389 390
+f 362 390 391
+f 362 391 392
+f 362 392 364
+f 364 392 366
+f 365 366 392
+f 365 392 394
+f 365 394 393
+f 369 395 370
+f 370 395 371
+f 371 394 396
+f 371 395 394
+f 372 396 373
+f 373 396 374
+f 374 396 397
+f 374 397 403
+f 374 403 398
+f 374 398 399
+f 374 399 400
+f 374 400 377
+f 376 379 380
+f 377 400 378
+f 378 400 379
+f 379 400 401
+f 381 401 382
+f 382 401 383
+f 383 401 400
+f 383 400 402
+f 383 402 384
+f 384 402 398
+f 384 398 385
+f 385 398 386
+f 386 398 403
+f 386 403 388
+f 386 388 387
+f 388 404 407
+f 388 407 405
+f 388 405 390
+f 388 390 389
+f 388 403 404
+f 390 405 406
+f 390 406 391
+f 391 394 392
+f 391 406 394
+f 393 394 395
+f 394 406 405
+f 394 405 407
+f 394 407 396
+f 396 407 404
+f 396 404 397
+f 397 404 403
+f 398 402 400
+f 398 400 399
+o convex_2
+v 0.0314144 0.0345938 -0.102607
+v 0.0399735 0.0317441 -0.102607
+v 0.0314144 0.0345938 -0.116892
+v -0.017094 0.0345938 -0.102607
+v 0.0399937 0.0317374 -0.102607
+v 0.0399735 0.0317441 -0.116892
+v 0.0314144 0.033883 -0.120103
+v 0.028558 0.0345938 -0.119745
+v -0.0256632 0.0345938 -0.111186
+v -0.0288716 0.033883 -0.111186
+v -0.0285095 0.0317441 -0.102607
+v 0.04285 0.0303092 -0.102607
+v 0.0418845 0.030792 -0.117843
+v 0.0399735 0.0310266 -0.120103
+v 0.028558 0.0326962 -0.123552
+v 0.028558 0.0336484 -0.12165
+v 0.0371272 0.0298398 -0.123552
+v 0.0142861 0.0345938 -0.122601
+v -0.0285095 0.0345938 -0.114039
+v -0.0370787 0.0317441 -0.114039
+v -0.0374307 0.0310266 -0.111186
+v -0.0370787 0.0288877 -0.102607
+v 0.0437854 0.0298398 -0.102607
+v 0.0437854 0.0298398 -0.115941
+v 0.0414017 0.0303159 -0.12046
+v 0.0299862 0.0303159 -0.124739
+v 0.0157143 0.0331723 -0.124739
+v 0.0142861 0.0336484 -0.124503
+v 0.0414017 0.0274595 -0.123313
+v 0.0385554 0.0274595 -0.124739
+v -0.0228068 0.0345938 -0.122601
+v -0.0285095 0.0345938 -0.119745
+v -0.0370787 0.0317441 -0.122601
+v -0.0442097 0.0281769 -0.121172
+v -0.0446824 0.0279356 -0.114039
+v -0.0431435 0.0281769 -0.111186
+v -0.0389696 0.0279423 -0.102607
+v 0.0466418 0.0241337 -0.102607
+v 0.0466418 0.0241337 -0.115941
+v 0.0447308 0.0279356 -0.117843
+v 0.0442581 0.0274595 -0.12046
+v 0.028558 0.0288877 -0.125454
+v 0.0142861 0.0317441 -0.125454
+v -0.00996309 0.0274595 -0.127595
+v -0.0228068 0.0336484 -0.124503
+v 0.0414017 0.0246098 -0.124739
+v 0.0437854 0.0231816 -0.123552
+v 0.0371272 0.0260313 -0.125454
+v -0.024235 0.033883 -0.124027
+v -0.0299377 0.033883 -0.121172
+v -0.0385069 0.0310266 -0.124027
+v -0.0442097 0.0267487 -0.124027
+v -0.0465933 0.0241337 -0.122601
+v -0.0446824 0.0279356 -0.119745
+v -0.0449238 0.0274595 -0.112613
+v -0.0434956 0.0274595 -0.109759
+v -0.046704 0.0231816 -0.111186
+v -0.0408806 0.0241337 -0.102607
+v 0.0485427 0.0203252 -0.102607
+v 0.0475872 0.0222295 -0.117843
+v 0.0485427 0.0203252 -0.116892
+v 0.0471145 0.0217534 -0.12046
+v -0.0113913 0.0260313 -0.128307
+v -0.0370787 0.0260313 -0.128307
+v -0.0370787 0.0298398 -0.126405
+v 0.0418845 0.0231816 -0.124503
+v 0.0399735 0.0231816 -0.125454
+v 0.0471145 0.018897 -0.121886
+v -0.0413533 0.0267487 -0.126881
+v -0.0442097 0.0238924 -0.126881
+v -0.0456379 0.0231816 -0.125454
+v -0.0470661 0.0224642 -0.124027
+v -0.0475388 0.0212773 -0.124503
+v -0.0484943 0.0203252 -0.122601
+v -0.0465933 0.0241337 -0.114039
+v -0.0477802 0.0217534 -0.112613
+v -0.0456379 0.0146191 -0.102607
+v 0.0513991 0.00890634 -0.102607
+v 0.0478286 0.0203252 -0.120103
+v 0.0485427 0.0174688 -0.119745
+v 0.0513991 0.00890634 -0.111186
+v 0.0513991 0.00605665 -0.116892
+v -0.0399251 -0.0167677 -0.128307
+v 0.0399735 0.0117627 -0.125454
+v -0.0427815 0.0203252 -0.128307
+v -0.0427815 0.023537 -0.127595
+v -0.0399251 0.0263934 -0.127595
+v 0.0418845 0.0117627 -0.124503
+v 0.0475872 0.0174688 -0.12165
+v -0.0446824 0.0212773 -0.127356
+v -0.0465933 0.0193731 -0.126405
+v -0.0475388 0.0127149 -0.127356
+v -0.0503952 0.00700878 -0.124503
+v -0.0513506 0.00605665 -0.122601
+v -0.0513506 0.0117627 -0.116892
+v -0.0484943 0.0203252 -0.114039
+v -0.0506365 0.0131909 -0.115466
+v -0.0506365 0.0103345 -0.112613
+v -0.0513506 0.00890634 -0.114039
+v -0.0456379 -0.013918 -0.102607
+v 0.0513991 -0.00820522 -0.102607
+v 0.0513991 -0.00820522 -0.116892
+v 0.050685 -0.00963341 -0.118319
+v 0.0494881 0.00605665 -0.120696
+v -0.0142376 -0.031043 -0.125454
+v -0.0394524 -0.019148 -0.127832
+v -0.0427815 -0.013918 -0.128307
+v 0.0142861 -0.0253302 -0.125454
+v 0.00572697 -0.0281866 -0.125454
+v 0.0456863 -0.013918 -0.122601
+v 0.0428299 -0.0196241 -0.122601
+v -0.0456379 0.0117627 -0.128307
+v 0.0475872 -0.013918 -0.12165
+v -0.0494397 0.00510451 -0.126405
+v -0.0513506 0.00035056 -0.122601
+v -0.0513506 -0.00820522 -0.114039
+v -0.0470661 -0.0210523 -0.110471
+v -0.0447528 -0.0160771 -0.102607
+v -0.0477802 -0.0196241 -0.110829
+v 0.0478286 -0.0199661 -0.102607
+v 0.0478286 -0.0199795 -0.102624
+v 0.0485427 -0.0196241 -0.105477
+v 0.0485427 -0.0196241 -0.116892
+v 0.0496088 -0.0110616 -0.119745
+v 0.0494881 -0.00820522 -0.120696
+v 0.0478286 -0.0210523 -0.118319
+v 0.0478286 -0.0153462 -0.121172
+v -0.0132922 -0.0329472 -0.124503
+v -0.0313659 -0.031043 -0.125454
+v 0.00668245 -0.0300908 -0.124503
+v -0.0370787 -0.0281866 -0.125454
+v -0.0413533 -0.0210523 -0.126881
+v -0.0423087 -0.0162983 -0.127832
+v -0.0442097 -0.0181959 -0.126881
+v -0.0465933 -0.0148701 -0.126405
+v -0.0456379 0.00035056 -0.128307
+v 0.0399735 -0.0224805 -0.122601
+v 0.0342708 -0.0253302 -0.122601
+v 0.0460383 -0.0167677 -0.121886
+v 0.043192 -0.0224805 -0.121886
+v -0.0494397 -0.000594867 -0.126405
+v -0.0513506 -0.00820522 -0.119745
+v -0.0494397 -0.00915735 -0.123552
+v -0.0484943 -0.0196241 -0.114039
+v -0.0475388 -0.0215284 -0.113088
+v -0.0442097 -0.0267584 -0.110471
+v -0.0442097 -0.0239087 -0.107618
+v -0.0420674 -0.021763 -0.102607
+v 0.0478186 -0.0199862 -0.102607
+v 0.0466418 -0.0234326 -0.105477
+v 0.0466418 -0.0234326 -0.116892
+v 0.043544 -0.0239087 -0.121172
+v 0.0466418 -0.0196241 -0.120696
+v -0.0142376 -0.0338927 -0.122601
+v -0.0304105 -0.0329472 -0.124503
+v 0.00477148 -0.0319951 -0.123552
+v 0.0123852 -0.0329472 -0.12165
+v -0.0356505 -0.0324712 -0.124027
+v 0.0257117 -0.0281866 -0.122601
+v 0.0266571 -0.0300908 -0.12165
+v -0.0413533 -0.0296148 -0.124027
+v -0.0442097 -0.0267584 -0.124027
+v -0.0470661 -0.0210523 -0.124027
+v 0.040929 -0.0243848 -0.12165
+v 0.0352162 -0.0272344 -0.12165
+v -0.0484943 -0.0196241 -0.119745
+v -0.0465933 -0.0234326 -0.114993
+v -0.0446824 -0.0272344 -0.113088
+v -0.041836 -0.0300908 -0.110235
+v -0.03904 -0.0274959 -0.102607
+v 0.0464004 -0.0221251 -0.102607
+v 0.0447308 -0.0243848 -0.102607
+v 0.0437854 -0.0262823 -0.108333
+v 0.0437854 -0.0262823 -0.116892
+v 0.0421158 -0.0267584 -0.118319
+v 0.040929 -0.0272344 -0.118794
+v 0.0378413 -0.0267584 -0.121172
+v -0.0313659 -0.0338927 -0.122601
+v 0.0114398 -0.0338927 -0.119745
+v 0.0257117 -0.031043 -0.119745
+v 0.018098 -0.0329472 -0.118794
+v -0.0370787 -0.0338927 -0.119745
+v -0.0380242 -0.0319951 -0.123552
+v 0.0292721 -0.0296148 -0.121172
+v 0.0323699 -0.0300908 -0.118794
+v -0.0408806 -0.0319951 -0.120696
+v -0.0437369 -0.0291387 -0.120696
+v -0.0465933 -0.0234326 -0.120696
+v -0.0437369 -0.0291387 -0.114993
+v -0.0408806 -0.0319951 -0.114993
+v -0.0389796 -0.0329472 -0.113088
+v -0.0385069 -0.0324712 -0.110471
+v -0.0399251 -0.0303255 -0.107976
+v -0.0335283 -0.0301579 -0.102607
+v 0.0314144 -0.031043 -0.102607
+v 0.0428299 -0.026403 -0.105477
+v 0.0414017 -0.0274758 -0.106904
+v 0.0418845 -0.0272344 -0.108333
+v 0.0418845 -0.0272344 -0.116892
+v 0.0399735 -0.0281866 -0.116892
+v 0.0171425 -0.0338927 -0.116892
+v 0.0314144 -0.031043 -0.116892
+v -0.0370787 -0.0338927 -0.114039
+v -0.0389796 -0.0329472 -0.118794
+v -0.0370787 -0.0331819 -0.110829
+v -0.0313659 -0.031043 -0.102607
+v 0.0399735 -0.0281866 -0.108333
+v 0.0171626 -0.033886 -0.102607
+v 0.0199989 -0.0338927 -0.105477
+v 0.0199989 -0.0338927 -0.114039
+v -0.0342223 -0.0338927 -0.111186
+v -0.017094 -0.0338927 -0.102607
+v 0.0114398 -0.0338927 -0.102607
+v 0.0171425 -0.0338927 -0.102624
+f 408 409 413
+f 408 413 410
+f 408 410 415
+f 408 415 425
+f 408 425 438
+f 408 438 439
+f 408 439 426
+f 408 426 416
+f 408 416 411
+f 408 411 418
+f 408 418 429
+f 408 429 444
+f 408 444 465
+f 408 465 484
+f 408 484 507
+f 408 507 525
+f 408 525 555
+f 408 555 577
+f 408 577 601
+f 408 601 613
+f 408 613 619
+f 408 619 620
+f 408 620 615
+f 408 615 602
+f 408 602 579
+f 408 579 578
+f 408 578 556
+f 408 556 527
+f 408 527 508
+f 408 508 485
+f 408 485 466
+f 408 466 445
+f 408 445 430
+f 408 430 419
+f 408 419 412
+f 408 412 409
+f 409 412 413
+f 410 414 415
+f 410 413 414
+f 411 416 417
+f 411 417 418
+f 412 419 420
+f 412 420 413
+f 413 420 421
+f 413 421 414
+f 414 422 423
+f 414 423 415
+f 414 421 424
+f 414 424 422
+f 415 423 425
+f 416 426 417
+f 417 426 427
+f 417 427 428
+f 417 428 429
+f 417 429 418
+f 419 430 431
+f 419 431 420
+f 420 432 421
+f 420 431 432
+f 421 432 424
+f 422 424 437
+f 422 437 433
+f 422 433 434
+f 422 434 435
+f 422 435 423
+f 423 435 425
+f 424 432 436
+f 424 436 437
+f 425 435 452
+f 425 452 438
+f 426 439 440
+f 426 440 427
+f 427 440 441
+f 427 441 442
+f 427 442 443
+f 427 443 428
+f 428 443 429
+f 429 443 444
+f 430 445 446
+f 430 446 431
+f 431 446 467
+f 431 467 447
+f 431 447 448
+f 431 448 432
+f 432 448 436
+f 433 449 450
+f 433 450 434
+f 433 437 455
+f 433 455 449
+f 434 450 435
+f 435 450 451
+f 435 451 452
+f 436 453 437
+f 436 448 454
+f 436 454 453
+f 437 453 474
+f 437 474 455
+f 438 452 456
+f 438 456 457
+f 438 457 439
+f 439 457 440
+f 440 458 441
+f 440 457 458
+f 441 459 460
+f 441 460 461
+f 441 461 442
+f 441 458 459
+f 442 461 462
+f 442 462 443
+f 443 462 463
+f 443 463 444
+f 444 463 464
+f 444 464 465
+f 445 466 468
+f 445 468 446
+f 446 468 467
+f 447 467 469
+f 447 469 448
+f 448 469 454
+f 449 455 470
+f 449 470 450
+f 450 470 451
+f 451 470 471
+f 451 471 472
+f 451 472 452
+f 452 472 456
+f 453 473 474
+f 453 454 473
+f 454 469 475
+f 454 475 496
+f 454 496 520
+f 454 520 517
+f 454 517 495
+f 454 495 473
+f 455 474 470
+f 456 472 458
+f 456 458 457
+f 458 472 476
+f 458 476 459
+f 459 476 477
+f 459 477 478
+f 459 478 479
+f 459 479 460
+f 460 479 480
+f 460 480 481
+f 460 481 503
+f 460 503 482
+f 460 482 462
+f 460 462 461
+f 462 482 483
+f 462 483 464
+f 462 464 463
+f 464 483 484
+f 464 484 465
+f 466 485 488
+f 466 488 468
+f 467 486 469
+f 467 468 486
+f 468 487 486
+f 468 488 489
+f 468 489 487
+f 469 486 475
+f 470 490 514
+f 470 514 543
+f 470 543 519
+f 470 519 492
+f 470 492 471
+f 470 474 491
+f 470 491 490
+f 471 492 493
+f 471 493 494
+f 471 494 472
+f 472 494 476
+f 473 495 491
+f 473 491 474
+f 475 486 496
+f 476 494 493
+f 476 493 477
+f 477 493 497
+f 477 497 498
+f 477 498 480
+f 477 480 478
+f 478 480 479
+f 480 498 499
+f 480 499 500
+f 480 500 501
+f 480 501 481
+f 481 501 502
+f 481 502 503
+f 482 503 483
+f 483 503 502
+f 483 502 504
+f 483 504 505
+f 483 505 484
+f 484 505 506
+f 484 506 523
+f 484 523 507
+f 485 508 509
+f 485 509 489
+f 485 489 488
+f 486 487 496
+f 487 489 496
+f 489 509 510
+f 489 510 511
+f 489 511 496
+f 490 512 513
+f 490 513 540
+f 490 540 514
+f 490 491 515
+f 490 515 516
+f 490 516 512
+f 491 495 517
+f 491 517 518
+f 491 518 515
+f 492 497 493
+f 492 519 499
+f 492 499 497
+f 496 511 532
+f 496 532 520
+f 497 499 498
+f 499 519 543
+f 499 543 548
+f 499 548 521
+f 499 521 500
+f 500 521 548
+f 500 548 522
+f 500 522 501
+f 501 522 549
+f 501 549 523
+f 501 523 506
+f 501 506 502
+f 502 506 505
+f 502 505 504
+f 507 524 525
+f 507 523 526
+f 507 526 524
+f 508 527 528
+f 508 528 529
+f 508 529 530
+f 508 530 509
+f 509 530 533
+f 509 533 510
+f 510 531 532
+f 510 532 511
+f 510 533 534
+f 510 534 531
+f 512 535 562
+f 512 562 536
+f 512 536 513
+f 512 516 537
+f 512 537 535
+f 513 538 539
+f 513 539 540
+f 513 536 538
+f 514 540 541
+f 514 541 542
+f 514 542 543
+f 515 518 544
+f 515 544 545
+f 515 545 566
+f 515 566 537
+f 515 537 516
+f 517 520 546
+f 517 546 547
+f 517 547 518
+f 518 547 544
+f 520 532 534
+f 520 534 546
+f 522 548 550
+f 522 550 549
+f 523 549 573
+f 523 573 551
+f 523 551 526
+f 524 526 552
+f 524 552 575
+f 524 575 553
+f 524 553 554
+f 524 554 525
+f 525 554 555
+f 526 551 552
+f 527 556 528
+f 528 556 557
+f 528 557 529
+f 529 557 558
+f 529 558 530
+f 530 558 533
+f 531 534 532
+f 533 558 559
+f 533 559 560
+f 533 560 534
+f 534 560 546
+f 535 561 585
+f 535 585 562
+f 535 537 563
+f 535 563 564
+f 535 564 561
+f 536 562 565
+f 536 565 538
+f 537 566 567
+f 537 567 563
+f 538 565 568
+f 538 568 539
+f 539 568 569
+f 539 569 541
+f 539 541 540
+f 541 569 542
+f 542 570 548
+f 542 548 543
+f 542 569 570
+f 544 547 571
+f 544 571 545
+f 545 571 572
+f 545 572 567
+f 545 567 566
+f 546 560 547
+f 547 560 559
+f 547 559 571
+f 548 570 550
+f 549 550 570
+f 549 570 573
+f 551 573 595
+f 551 595 574
+f 551 574 552
+f 552 574 596
+f 552 596 575
+f 553 576 577
+f 553 577 554
+f 553 575 576
+f 554 577 555
+f 556 578 557
+f 557 578 579
+f 557 579 580
+f 557 580 581
+f 557 581 558
+f 558 581 559
+f 559 581 582
+f 559 582 583
+f 559 583 584
+f 559 584 571
+f 561 564 586
+f 561 586 608
+f 561 608 617
+f 561 617 616
+f 561 616 621
+f 561 621 620
+f 561 620 619
+f 561 619 618
+f 561 618 610
+f 561 610 589
+f 561 589 585
+f 562 585 565
+f 563 567 564
+f 564 567 587
+f 564 587 588
+f 564 588 586
+f 565 589 590
+f 565 590 568
+f 565 585 589
+f 567 572 584
+f 567 584 591
+f 567 591 592
+f 567 592 587
+f 568 593 594
+f 568 594 569
+f 568 590 593
+f 569 594 595
+f 569 595 570
+f 570 595 573
+f 571 584 572
+f 574 595 594
+f 574 594 596
+f 575 596 576
+f 576 596 597
+f 576 597 598
+f 576 598 599
+f 576 599 600
+f 576 600 577
+f 577 600 601
+f 579 602 603
+f 579 603 580
+f 580 603 604
+f 580 604 605
+f 580 605 606
+f 580 606 581
+f 581 606 583
+f 581 583 582
+f 583 606 607
+f 583 607 609
+f 583 609 592
+f 583 592 584
+f 584 592 591
+f 586 588 608
+f 587 592 609
+f 587 609 588
+f 588 609 608
+f 589 610 598
+f 589 598 611
+f 589 611 593
+f 589 593 590
+f 593 597 596
+f 593 596 594
+f 593 611 598
+f 593 598 597
+f 598 610 612
+f 598 612 599
+f 599 612 613
+f 599 613 601
+f 599 601 600
+f 602 609 607
+f 602 607 614
+f 602 614 604
+f 602 604 603
+f 602 615 616
+f 602 616 617
+f 602 617 609
+f 604 614 607
+f 604 607 606
+f 604 606 605
+f 608 609 617
+f 610 618 612
+f 612 618 619
+f 612 619 613
+f 615 620 621
+f 615 621 616
+o convex_3
+v 0.0228511 0.0346005 0.0686284
+v 0.025387 0.0342755 0.0673881
+v 0.0228511 0.0346005 0.0673881
+v 0.0171472 0.0346005 0.0771906
+v 0.00573144 0.0346005 0.0943113
+v 0.0199992 0.0317414 0.0886044
+v 0.0271371 0.0331682 0.070056
+v 0.031415 0.0317414 0.0686284
+v 0.0301754 0.0323639 0.0673881
+v -0.00853629 0.0346005 0.0673881
+v 0.00667938 0.0326944 0.0981184
+v 0.0157213 0.0303146 0.0985943
+v 0.0214251 0.0303146 0.0928874
+v -0.00282434 0.0346005 0.0943113
+v 0.028563 0.0317414 0.074339
+v 0.0328409 0.0303146 0.0729114
+v 0.0352229 0.0298409 0.0695801
+v 0.033319 0.0307939 0.0676766
+v 0.033319 0.0307939 0.0673881
+v -0.0161441 0.0307939 0.0673881
+v -0.0185261 0.0310308 0.0729114
+v -0.0171002 0.0317414 0.074339
+v -0.00853629 0.0346005 0.0829013
+v 0.0095313 0.0298409 0.100974
+v -0.0018764 0.0326944 0.0981184
+v 0.00291192 0.0260674 0.105665
+v 0.0095313 0.0269873 0.103825
+v 0.0238071 0.0269873 0.0981184
+v 0.029989 0.0274611 0.0871768
+v 0.029989 0.0303146 0.0786183
+v -0.00567626 0.0346005 0.0914597
+v -0.00604086 0.0338843 0.0943113
+v -0.00378038 0.0336475 0.0962149
+v 0.032371 0.0298409 0.0752908
+v 0.0352229 0.0298409 0.0673881
+v 0.0339023 0.0305019 0.0673881
+v 0.0347449 0.0293671 0.0719596
+v 0.0380749 0.0269873 0.0724355
+v -0.0180481 0.0298409 0.0673881
+v -0.0171002 0.0317414 0.0886044
+v -0.0209 0.0298409 0.074339
+v -0.026612 0.0269873 0.0857528
+v -0.024708 0.0279404 0.0857528
+v -0.024708 0.0279404 0.0886044
+v -0.00601655 0.0253567 0.105665
+v -0.00288105 0.0260509 0.105665
+v -0.00279193 0.0260674 0.105665
+v 0.00973385 0.0243376 0.105665
+v 0.0128613 0.0246076 0.104301
+v 0.0271371 0.0246076 0.0985943
+v 0.032371 0.0269873 0.083853
+v 0.031893 0.0293671 0.0776665
+v -0.0174567 0.0310308 0.0914597
+v -0.00639735 0.0331682 0.095739
+v -0.0145966 0.0310308 0.0943113
+v 0.0380749 0.0269873 0.0673881
+v 0.0385529 0.0246076 0.0757629
+v 0.0404569 0.0236545 0.0719596
+v 0.0409268 0.0241338 0.0695801
+v 0.032371 0.0241338 0.0895562
+v -0.0190285 0.0291137 0.0673881
+v -0.02709 0.0253237 0.0786183
+v -0.0294639 0.0241338 0.0829013
+v -0.026612 0.0269873 0.0886044
+v -0.0231605 0.0281772 0.0914597
+v -0.00610567 0.0253237 0.105665
+v -0.0149531 0.0303146 0.095739
+v 0.0115001 0.0232469 0.105665
+v 0.0271371 0.0189005 0.10145
+v 0.0290411 0.0179474 0.100498
+v 0.031893 0.0179474 0.0976425
+v 0.0328409 0.0189005 0.095739
+v 0.0328409 0.021754 0.0928874
+v 0.0242771 0.021754 0.10145
+v -0.0178131 0.0303146 0.0928874
+v 0.0418828 0.0222278 0.0676766
+v 0.041656 0.0224096 0.0673881
+v 0.035701 0.0189005 0.0900321
+v 0.0414048 0.021754 0.0729114
+v 0.0428308 0.0203272 0.0686284
+v -0.0206975 0.0274005 0.0673881
+v -0.026612 0.0212803 0.0673881
+v -0.0323158 0.0184267 0.0800459
+v -0.0335068 0.0189005 0.0871768
+v -0.0324374 0.0203272 0.0886044
+v -0.0294639 0.0241338 0.0886044
+v -0.023517 0.0274611 0.0928874
+v -0.0118095 0.0224701 0.105665
+v -0.0149531 0.021754 0.104301
+v 0.0143601 0.0203933 0.105665
+v 0.029511 0.0155676 0.100974
+v 0.0172121 0.0175398 0.105665
+v 0.0182977 0.0157715 0.105665
+v 0.0257111 0.0146201 0.102877
+v 0.0328409 0.0131934 0.0985943
+v 0.032371 0.0155676 0.0981184
+v 0.0419152 0.0219854 0.0673881
+v 0.0371269 0.0146201 0.0886044
+v 0.0414048 0.0160469 0.0786183
+v 0.0423609 0.0198535 0.0710078
+v 0.0456908 0.00890753 0.0686284
+v 0.0425553 0.0203272 0.0673881
+v -0.028516 0.0174737 0.0673881
+v -0.0332719 0.0155676 0.0781424
+v -0.0327939 0.0167575 0.0786183
+v -0.0332719 0.0165207 0.0800459
+v -0.0342198 0.0146201 0.0800459
+v -0.0370798 0.00890753 0.0857528
+v -0.0363588 0.0103398 0.0871768
+v -0.0335068 0.0160469 0.0900321
+v -0.0306549 0.021754 0.0900321
+v -0.0288725 0.0231808 0.090744
+v -0.0142725 0.0203933 0.105665
+v 0.033319 0.00796002 0.0990702
+v 0.0186056 0.014554 0.105665
+v 0.0257111 0.0003524 0.102877
+v 0.0342669 0.00890753 0.0971667
+v 0.0428308 0.0117666 0.0771906
+v 0.0423609 0.0141409 0.0767147
+v 0.0456908 0.0060595 0.0686284
+v 0.0450669 0.00890753 0.0673881
+v 0.0428308 0.0190822 0.0673881
+v -0.028516 -0.00250115 0.0673881
+v -0.0370798 0.0060595 0.0857528
+v -0.0351759 0.00890753 0.0895562
+v -0.0352893 0.0117666 0.0886044
+v -0.0323158 0.0117666 0.0924115
+v -0.0185585 0.0117666 0.105665
+v -0.0171974 0.014554 0.105665
+v -0.0171326 0.0146862 0.105665
+v -0.0143455 0.0202611 0.105665
+v 0.029511 0.00130542 0.100974
+v 0.030467 -0.000600619 0.0990702
+v 0.0328409 0.00534886 0.0985943
+v 0.0328409 -0.000358233 0.095739
+v 0.033319 0.00225844 0.0962149
+v 0.0390309 0.00225844 0.0848011
+v 0.0418828 0.00225844 0.0790942
+v 0.0186056 0.000286294 0.105665
+v 0.0172121 -0.0025342 0.105665
+v 0.027607 -0.000600619 0.101926
+v 0.0428308 0.00320595 0.0771906
+v 0.0428308 -0.0053547 0.0686284
+v 0.042215 -0.00659968 0.0673881
+v 0.0450669 0.00482002 0.0673881
+v 0.0421178 -5.67076e-06 0.0771906
+v 0.0421178 -0.00285922 0.074339
+v 0.0421178 -0.00571277 0.0714837
+v -0.0281595 -0.00392241 0.0673881
+v -0.0327939 -0.00392792 0.0786183
+v -0.0342198 0.0003524 0.0800459
+v -0.0337499 -0.00202739 0.0805218
+v -0.0342198 -0.00250115 0.0829013
+v -0.0342198 -0.00250115 0.0886044
+v -0.0332719 -0.00250115 0.090508
+v -0.0351759 0.0060595 0.0895562
+v -0.026612 0.0060595 0.0981184
+v -0.0185585 0.00320595 0.105665
+v 0.0271371 -0.00321178 0.10145
+v 0.029989 -0.00321178 0.0985943
+v 0.035701 -0.000358233 0.0900321
+v 0.0385529 -0.000358233 0.0843289
+v 0.0414048 -0.000358233 0.0786183
+v 0.0257111 -0.00285922 0.102162
+v 0.0143601 -0.00538775 0.105665
+v 0.0418828 -0.00725522 0.0686284
+v 0.0409268 -0.00916126 0.0686284
+v 0.0420854 -0.00684207 0.0673881
+v 0.0414048 -0.00607084 0.0729114
+v -0.0277139 -0.00500764 0.0673881
+v -0.0323158 -0.00630771 0.0819495
+v -0.0259314 -0.00820824 0.0673881
+v -0.0237601 -0.0120148 0.0673881
+v -0.0332719 -0.00440168 0.083853
+v -0.0332719 -0.00440168 0.0895562
+v -0.0327939 -0.00392792 0.090744
+v -0.0323158 0.0003524 0.0924115
+v -0.0183398 0.00233556 0.105665
+v 0.0271371 -0.00749761 0.0985943
+v 0.027607 -0.00630771 0.0990702
+v 0.0214251 -0.00892439 0.10145
+v 0.029989 -0.00607084 0.095739
+v 0.035701 -0.00607084 0.0843289
+v 0.0199992 -0.00856631 0.102162
+v 0.00858336 -0.00932102 0.105665
+v 0.0409835 -0.0087481 0.0673881
+v 0.0380749 -0.0120148 0.0714837
+v 0.0380749 -0.0120148 0.0673881
+v 0.035701 -0.00892439 0.0814736
+v 0.0385529 -0.00892439 0.0757629
+v -0.0294639 -0.00916126 0.0790942
+v -0.0323158 -0.00630771 0.0876526
+v -0.026612 -0.0120148 0.0790942
+v -0.0209 -0.0148684 0.0673881
+v -0.02709 -0.00963502 0.0921717
+v -0.0313679 -0.00250115 0.0925277
+v -0.0156661 -0.00678147 0.103589
+v -0.0156661 -0.00392792 0.105017
+v -0.0151557 -0.0034101 0.105665
+v 0.031415 -0.012136 0.0829013
+v 0.0328409 -0.0103512 0.0843289
+v 0.0328409 -0.00892439 0.0871768
+v 0.0214251 -0.0117779 0.0985943
+v 0.0257111 -0.012136 0.0914597
+v 0.0171472 -0.0120148 0.100974
+v 0.00858336 -0.0148684 0.100974
+v 2.75871e-05 -0.0110948 0.105665
+v 0.0352229 -0.0120148 0.0771906
+v 0.0342669 -0.0149896 0.0714837
+v 0.0352229 -0.0148684 0.0686284
+v 0.0352229 -0.0148684 0.0673881
+v -0.026612 -0.0120148 0.0876526
+v -0.0165492 -0.0181681 0.0673881
+v -0.02423 -0.0124886 0.0921717
+v -0.0213781 -0.0124886 0.095027
+v -0.0118095 -0.00749761 0.105665
+v 0.0328409 -0.0132047 0.0786183
+v 0.0157213 -0.0146315 0.0985943
+v 0.0171472 -0.0149896 0.0971667
+v 0.0214251 -0.0132047 0.095739
+v 0.0271371 -0.0132047 0.0871768
+v 0.0128613 -0.0160583 0.0985943
+v 2.75871e-05 -0.0177219 0.0981184
+v -6.96376e-05 -0.0110948 0.105665
+v 0.028563 -0.0149896 0.0800459
+v 0.0328409 -0.0160583 0.070056
+v 0.031415 -0.0167744 0.0686284
+v 0.031415 -0.0167744 0.0673881
+v -0.024708 -0.0129678 0.0895562
+v -0.0155932 -0.0187465 0.0673881
+v -0.018996 -0.0158214 0.0924115
+v -0.0185261 -0.0153421 0.0935994
+v -0.0171002 -0.0148684 0.0952631
+v -0.0113882 -0.0148684 0.0981184
+v -0.00853629 -0.0088087 0.105665
+v 0.0157213 -0.0160583 0.095739
+v 0.0114353 -0.0167744 0.0971667
+v 0.00145355 -0.0189118 0.095739
+v -0.00282434 -0.0177219 0.0981184
+v 2.75871e-05 -0.0196279 0.0943113
+v -0.00282434 -0.0106597 0.105665
+v 0.0271371 -0.0160583 0.0786183
+v 0.0273153 -0.0187741 0.0673881
+v 0.0305886 -0.0171876 0.0673881
+v -0.0142401 -0.0192699 0.0673881
+v -0.0113882 -0.0196279 0.0829013
+v -0.0171002 -0.0167744 0.0914597
+v -0.0104403 -0.0186749 0.0924115
+v -0.00996225 -0.0182012 0.0935994
+v -0.00853629 -0.0177219 0.0952631
+v -0.00711033 -0.0153421 0.0993063
+v -0.00655129 -0.00945323 0.105665
+v 0.0142872 -0.0167744 0.0943113
+v 0.0114353 -0.0196279 0.0829013
+v 0.00287951 -0.0196279 0.0914597
+v -0.00567626 -0.0189118 0.0946711
+v -0.00282434 -0.0196279 0.0943113
+v 0.00660646 -0.0216772 0.0673881
+v 0.00733565 -0.0216276 0.0673881
+v 0.0142872 -0.0196279 0.0800459
+v 0.0269507 -0.0188677 0.0673881
+v -0.0126278 -0.0196279 0.0673881
+v -0.00336718 -0.0215725 0.0673881
+v -0.00282434 -0.0216772 0.0673881
+v -0.00853629 -0.0196279 0.0914597
+v 0.0228511 -0.0196279 0.0673881
+v 0.0228511 -0.0196279 0.0686284
+f 622 623 624
+f 622 624 631
+f 622 631 644
+f 622 644 652
+f 622 652 635
+f 622 635 626
+f 622 626 625
+f 622 625 623
+f 623 625 626
+f 623 626 627
+f 623 627 628
+f 623 628 629
+f 623 629 630
+f 623 630 640
+f 623 640 657
+f 623 657 656
+f 623 656 677
+f 623 677 698
+f 623 698 718
+f 623 718 723
+f 623 723 743
+f 623 743 742
+f 623 742 766
+f 623 766 765
+f 623 765 789
+f 623 789 807
+f 623 807 809
+f 623 809 832
+f 623 832 849
+f 623 849 865
+f 623 865 864
+f 623 864 882
+f 623 882 887
+f 623 887 880
+f 623 880 879
+f 623 879 885
+f 623 885 884
+f 623 884 883
+f 623 883 866
+f 623 866 851
+f 623 851 834
+f 623 834 815
+f 623 815 794
+f 623 794 793
+f 623 793 791
+f 623 791 770
+f 623 770 744
+f 623 744 724
+f 623 724 703
+f 623 703 702
+f 623 702 682
+f 623 682 660
+f 623 660 641
+f 623 641 631
+f 623 631 624
+f 626 632 633
+f 626 633 634
+f 626 634 627
+f 626 635 654
+f 626 654 646
+f 626 646 632
+f 627 634 636
+f 627 636 628
+f 628 636 637
+f 628 637 629
+f 629 637 638
+f 629 638 630
+f 630 638 639
+f 630 639 640
+f 631 641 642
+f 631 642 643
+f 631 643 661
+f 631 661 644
+f 632 645 633
+f 632 646 668
+f 632 668 647
+f 632 647 645
+f 633 645 648
+f 633 648 649
+f 633 649 634
+f 634 649 650
+f 634 650 651
+f 634 651 636
+f 635 652 653
+f 635 653 654
+f 636 651 637
+f 637 651 655
+f 637 655 638
+f 638 656 657
+f 638 657 639
+f 638 655 658
+f 638 658 659
+f 638 659 680
+f 638 680 677
+f 638 677 656
+f 639 657 640
+f 641 660 642
+f 642 661 643
+f 642 660 662
+f 642 662 663
+f 642 663 664
+f 642 664 665
+f 642 665 661
+f 644 661 652
+f 645 647 648
+f 646 654 666
+f 646 666 667
+f 646 667 668
+f 647 668 667
+f 647 667 666
+f 647 666 687
+f 647 687 709
+f 647 709 734
+f 647 734 752
+f 647 752 751
+f 647 751 750
+f 647 750 749
+f 647 749 779
+f 647 779 799
+f 647 799 820
+f 647 820 837
+f 647 837 856
+f 647 856 873
+f 647 873 862
+f 647 862 845
+f 647 845 828
+f 647 828 806
+f 647 806 786
+f 647 786 761
+f 647 761 760
+f 647 760 736
+f 647 736 714
+f 647 714 713
+f 647 713 711
+f 647 711 689
+f 647 689 669
+f 647 669 648
+f 648 669 670
+f 648 670 671
+f 648 671 649
+f 649 671 650
+f 650 671 672
+f 650 672 651
+f 651 672 673
+f 651 673 655
+f 652 661 674
+f 652 674 653
+f 653 675 654
+f 653 674 676
+f 653 676 688
+f 653 688 675
+f 654 675 666
+f 655 673 672
+f 655 672 659
+f 655 659 658
+f 659 678 679
+f 659 679 680
+f 659 672 681
+f 659 681 678
+f 660 682 662
+f 661 665 674
+f 662 682 683
+f 662 683 684
+f 662 684 663
+f 663 685 665
+f 663 665 664
+f 663 684 707
+f 663 707 685
+f 665 685 686
+f 665 686 674
+f 666 675 688
+f 666 688 687
+f 669 689 670
+f 670 689 671
+f 671 690 691
+f 671 691 692
+f 671 692 693
+f 671 693 694
+f 671 694 681
+f 671 681 672
+f 671 689 695
+f 671 695 690
+f 674 696 688
+f 674 688 676
+f 674 686 708
+f 674 708 696
+f 677 680 697
+f 677 697 698
+f 678 699 700
+f 678 700 679
+f 678 681 694
+f 678 694 699
+f 679 700 680
+f 680 700 701
+f 680 701 697
+f 682 702 683
+f 683 702 703
+f 683 703 684
+f 684 704 705
+f 684 705 706
+f 684 706 707
+f 684 703 704
+f 685 708 686
+f 685 707 708
+f 687 688 709
+f 688 696 708
+f 688 708 710
+f 688 710 709
+f 689 711 690
+f 689 690 695
+f 690 712 691
+f 690 711 713
+f 690 713 714
+f 690 714 715
+f 690 715 712
+f 691 712 716
+f 691 716 717
+f 691 717 692
+f 692 717 693
+f 693 717 716
+f 693 716 699
+f 693 699 694
+f 697 701 718
+f 697 718 698
+f 699 719 739
+f 699 739 720
+f 699 720 700
+f 699 716 719
+f 700 720 721
+f 700 721 701
+f 701 722 723
+f 701 723 718
+f 701 721 722
+f 703 724 725
+f 703 725 726
+f 703 726 704
+f 704 726 725
+f 704 725 727
+f 704 727 705
+f 705 727 728
+f 705 728 729
+f 705 729 730
+f 705 730 731
+f 705 731 706
+f 706 731 732
+f 706 732 707
+f 707 732 733
+f 707 733 708
+f 708 733 732
+f 708 732 710
+f 709 710 734
+f 710 732 734
+f 712 735 716
+f 712 715 735
+f 714 736 715
+f 715 736 760
+f 715 760 737
+f 715 737 735
+f 716 735 738
+f 716 738 719
+f 719 738 739
+f 720 739 740
+f 720 740 721
+f 721 740 722
+f 722 739 763
+f 722 763 741
+f 722 741 766
+f 722 766 742
+f 722 742 743
+f 722 743 723
+f 722 740 739
+f 724 744 745
+f 724 745 729
+f 724 729 728
+f 724 728 725
+f 725 728 727
+f 729 745 777
+f 729 777 746
+f 729 746 730
+f 730 746 747
+f 730 747 731
+f 731 747 746
+f 731 746 748
+f 731 748 749
+f 731 749 750
+f 731 750 751
+f 731 751 732
+f 732 751 752
+f 732 752 734
+f 735 737 753
+f 735 753 754
+f 735 754 781
+f 735 781 755
+f 735 755 756
+f 735 756 757
+f 735 757 758
+f 735 758 759
+f 735 759 763
+f 735 763 738
+f 737 760 761
+f 737 761 762
+f 737 762 753
+f 738 763 739
+f 741 764 765
+f 741 765 766
+f 741 763 767
+f 741 767 768
+f 741 768 769
+f 741 769 764
+f 744 770 771
+f 744 771 772
+f 744 772 745
+f 745 772 773
+f 745 773 774
+f 745 774 775
+f 745 775 776
+f 745 776 777
+f 746 777 778
+f 746 778 748
+f 748 778 749
+f 749 778 779
+f 753 762 780
+f 753 780 781
+f 753 781 754
+f 755 781 756
+f 756 781 782
+f 756 782 757
+f 757 782 758
+f 758 782 783
+f 758 783 759
+f 759 783 784
+f 759 784 767
+f 759 767 763
+f 761 785 762
+f 761 786 785
+f 762 785 780
+f 764 769 787
+f 764 787 765
+f 765 787 788
+f 765 788 789
+f 767 784 790
+f 767 790 768
+f 768 790 769
+f 769 790 788
+f 769 788 787
+f 770 791 771
+f 771 792 774
+f 771 774 773
+f 771 773 772
+f 771 791 793
+f 771 793 794
+f 771 794 792
+f 774 792 795
+f 774 795 796
+f 774 796 775
+f 775 796 776
+f 776 796 797
+f 776 797 798
+f 776 798 777
+f 777 798 778
+f 778 798 779
+f 779 798 799
+f 780 800 801
+f 780 801 781
+f 780 785 802
+f 780 802 800
+f 781 801 800
+f 781 800 803
+f 781 803 804
+f 781 804 782
+f 782 804 783
+f 783 804 790
+f 783 790 784
+f 785 786 805
+f 785 805 802
+f 786 806 805
+f 788 807 789
+f 788 790 808
+f 788 808 831
+f 788 831 832
+f 788 832 809
+f 788 809 807
+f 790 804 810
+f 790 810 811
+f 790 811 808
+f 792 812 814
+f 792 814 833
+f 792 833 813
+f 792 813 796
+f 792 796 795
+f 792 794 812
+f 794 814 812
+f 794 815 814
+f 796 813 816
+f 796 816 797
+f 797 817 798
+f 797 816 818
+f 797 818 819
+f 797 819 799
+f 797 799 817
+f 798 817 799
+f 799 819 820
+f 800 821 822
+f 800 822 823
+f 800 823 803
+f 800 802 824
+f 800 824 825
+f 800 825 821
+f 802 805 806
+f 802 806 826
+f 802 826 824
+f 803 823 810
+f 803 810 804
+f 806 827 826
+f 806 828 827
+f 808 811 810
+f 808 810 829
+f 808 829 830
+f 808 830 831
+f 810 823 829
+f 813 833 816
+f 814 815 834
+f 814 834 833
+f 816 833 835
+f 816 835 836
+f 816 836 818
+f 818 837 820
+f 818 820 819
+f 818 836 837
+f 821 838 822
+f 821 825 842
+f 821 842 838
+f 822 838 829
+f 822 829 823
+f 824 826 839
+f 824 839 840
+f 824 840 841
+f 824 841 825
+f 825 841 842
+f 826 827 843
+f 826 843 839
+f 827 828 844
+f 827 844 843
+f 828 845 860
+f 828 860 844
+f 829 838 830
+f 830 838 846
+f 830 846 863
+f 830 863 847
+f 830 847 831
+f 831 847 848
+f 831 848 849
+f 831 849 832
+f 833 850 835
+f 833 834 851
+f 833 851 850
+f 835 850 852
+f 835 852 836
+f 836 852 853
+f 836 853 854
+f 836 854 837
+f 837 854 855
+f 837 855 856
+f 838 842 846
+f 839 843 840
+f 840 843 857
+f 840 857 863
+f 840 863 846
+f 840 846 842
+f 840 842 841
+f 843 858 857
+f 843 844 859
+f 843 859 861
+f 843 861 858
+f 844 860 878
+f 844 878 861
+f 844 861 859
+f 845 862 860
+f 847 863 864
+f 847 864 848
+f 848 864 865
+f 848 865 849
+f 850 851 852
+f 851 866 867
+f 851 867 868
+f 851 868 852
+f 852 868 869
+f 852 869 870
+f 852 870 853
+f 853 870 854
+f 854 870 871
+f 854 871 860
+f 854 860 855
+f 855 860 872
+f 855 872 856
+f 856 872 873
+f 857 858 874
+f 857 874 864
+f 857 864 863
+f 858 875 881
+f 858 881 874
+f 858 861 876
+f 858 876 875
+f 860 862 872
+f 860 871 877
+f 860 877 878
+f 861 878 885
+f 861 885 879
+f 861 879 880
+f 861 880 876
+f 862 873 872
+f 864 874 881
+f 864 881 882
+f 866 883 867
+f 867 883 884
+f 867 884 885
+f 867 885 886
+f 867 886 868
+f 868 886 869
+f 869 886 877
+f 869 877 870
+f 870 877 871
+f 875 880 881
+f 875 876 880
+f 877 886 878
+f 878 886 885
+f 880 887 888
+f 880 888 881
+f 881 888 882
+f 882 888 887
+o convex_4
+v 0.025708 0.0346005 0.0657713
+v 0.0228511 0.0346005 0.0629188
+v 0.0228511 0.0346005 0.0673843
+v 0.0253871 0.0342764 0.0673843
+v 0.0301695 0.0323654 0.0673843
+v 0.031414 0.0317452 0.0673843
+v 0.0330264 0.0309406 0.0673843
+v 0.031414 0.0317452 0.0657713
+v 0.02761 0.033645 0.0648205
+v 0.0342709 0.0288899 0.045702
+v 0.0142881 0.0317452 0.045702
+v 0.011439 0.0346005 0.0572096
+v -0.00853598 0.0346005 0.0673843
+v 0.035218 0.0298398 0.0673843
+v 0.035218 0.0298398 0.0667242
+v 0.033316 0.0307897 0.0648205
+v 0.0370339 0.0275098 0.045702
+v -0.022805 0.0317452 0.045702
+v -0.00567906 0.0346005 0.0515046
+v 0.00288389 0.0346005 0.0543571
+v -0.0113851 0.0346005 0.0600642
+v -0.019948 0.0317452 0.0543571
+v -0.0203081 0.03103 0.0572096
+v -0.0150717 0.0313317 0.0673843
+v 0.0380749 0.0269845 0.0673843
+v 0.0380749 0.0269845 0.045702
+v -0.0247696 0.0307618 0.045702
+v -0.022805 0.0317452 0.0457954
+v -0.0113851 0.0346005 0.0515046
+v -0.0237599 0.0298398 0.0543571
+v -0.018046 0.0298398 0.0673843
+v 0.0416598 0.0224083 0.0673843
+v 0.040564 0.0237717 0.045702
+v -0.026609 0.0298398 0.045702
+v -0.026609 0.0298398 0.0457954
+v -0.0277987 0.0274595 0.0500762
+v -0.0220927 0.0274595 0.064345
+v -0.0190322 0.0291134 0.0673843
+v 0.0419103 0.0219836 0.0673843
+v 0.0421686 0.0202347 0.045702
+v -0.0266872 0.0297895 0.045702
+v -0.026609 0.0212796 0.0673843
+v -0.0295285 0.0269566 0.045702
+v -0.0295833 0.0260346 0.04865
+v -0.0206916 0.0274036 0.0673843
+v 0.0425599 0.0203241 0.0673843
+v 0.0450177 0.0116744 0.045702
+v -0.0324167 0.0232744 0.045702
+v -0.0324402 0.0231794 0.0457954
+v -0.0279787 0.0185472 0.0673843
+v 0.0428339 0.0190836 0.0673843
+v 0.0455969 0.00937234 0.045702
+v -0.0325107 0.02309 0.045702
+v -0.028511 0.0174744 0.0673843
+v 0.0450646 0.00890857 0.0673843
+v 0.0456908 0.00890857 0.0457954
+v 0.0456908 0.00890857 0.045702
+v -0.0342561 0.0174744 0.045702
+v -0.0335047 0.0188993 0.0472216
+v -0.028511 -0.00250136 0.0673843
+v -0.0342248 0.0117638 0.04865
+v -0.0313679 0.00605888 0.0600642
+v 0.0450646 0.00481843 0.0673843
+v 0.0456908 0.00320919 0.0457954
+v 0.0456908 0.0031142 0.045702
+v -0.0342718 0.0173347 0.045702
+v -0.0281588 -0.00392062 0.0673843
+v -0.0342248 0.000353913 0.04865
+v -0.0342248 -0.00535664 0.0457954
+v -0.0335047 -0.00821192 0.0461519
+v 0.0449942 7.47988e-06 0.045702
+v 0.0422077 -0.0065971 0.0673843
+v -0.0342718 -0.00250136 0.045702
+v -0.0277126 -0.00501021 0.0673843
+v -0.0335047 -0.00865893 0.045702
+v -0.0342405 -0.00535664 0.045702
+v -0.0342248 -0.00544604 0.045702
+v -0.0336065 -0.00821192 0.045702
+v 0.0428339 -0.00535664 0.04865
+v 0.0428104 -0.00545722 0.045702
+v 0.0420903 -0.00684295 0.0673843
+v 0.0421216 -0.00678149 0.0671997
+v -0.0270864 -0.00678149 0.0664865
+v -0.0259358 -0.00821192 0.0673843
+v -0.0327924 -0.00963677 0.0465085
+v -0.0299434 -0.0153417 0.0465085
+v -0.0308357 -0.0139169 0.045702
+v 0.0409632 -0.00914505 0.045702
+v 0.0409788 -0.00874833 0.0673843
+v 0.0409319 -0.00916182 0.04865
+v -0.0237599 -0.0120171 0.0673843
+v -0.0286049 -0.0167275 0.045702
+v -0.0270864 -0.018197 0.0465085
+v -0.0306087 -0.0142968 0.045702
+v -0.0299434 -0.0153417 0.045702
+v 0.0409006 -0.00922328 0.045702
+v 0.0380749 -0.0120171 0.0673843
+v -0.0209029 -0.0148668 0.0673843
+v -0.0270864 -0.018197 0.045702
+v -0.0260376 -0.0188675 0.045702
+v -0.024707 -0.018672 0.0496008
+v -0.0213804 -0.018197 0.0579227
+v 0.035218 -0.0148668 0.0673843
+v 0.0381062 -0.0120003 0.045702
+v -0.016551 -0.0181691 0.0673843
+v -0.0256619 -0.0190128 0.045702
+v -0.022805 -0.0196274 0.04865
+v -0.016144 -0.018672 0.0667242
+v 0.0343962 -0.0152859 0.0673843
+v 0.035218 -0.0148668 0.0657713
+v 0.0380436 -0.0120394 0.045702
+v -0.0155883 -0.0187446 0.0673843
+v -0.0228989 -0.0196274 0.045702
+v -0.014242 -0.0224827 0.04865
+v -0.014242 -0.0196274 0.0657713
+v 0.033316 -0.0158223 0.0657713
+v 0.031414 -0.0167722 0.0673843
+v 0.0271325 -0.0189122 0.0671997
+v 0.025708 -0.0196274 0.0657713
+v 0.0362042 -0.0129614 0.045702
+v -0.014242 -0.0192698 0.0673843
+v -0.0143359 -0.0210076 0.045702
+v -0.00282213 -0.0224827 0.0543571
+v -0.0113851 -0.0224827 0.0543571
+v -0.0132949 -0.0215272 0.0467462
+v 0.00572516 -0.0196274 0.045702
+v -0.00567906 -0.0224827 0.0629188
+v 0.0305843 -0.0171857 0.0673843
+v 0.0273204 -0.0187725 0.0673843
+v 0.0269525 -0.0188675 0.0673843
+v 0.0228511 -0.0196274 0.0673843
+v 0.011439 -0.0224827 0.0629188
+v 0.0157205 -0.0217675 0.0614904
+v 0.025708 -0.0167722 0.045702
+v 0.034177 -0.0139504 0.045702
+v 0.0342709 -0.0139169 0.045702
+v -0.00567906 -0.0217675 0.06613
+v -0.0126296 -0.0196274 0.0673843
+v 0.00288389 -0.0224827 0.0572096
+v 0.00858208 -0.0224827 0.0600642
+v -0.00282213 -0.0224827 0.0657713
+v 0.00733756 -0.0216278 0.0673843
+v 0.00715753 -0.0217675 0.0671997
+v 0.00572516 -0.0224827 0.0657713
+v -0.00336221 -0.0215719 0.0673843
+v -0.00282213 -0.0216725 0.0673843
+v 0.0066018 -0.0216725 0.0673843
+f 889 890 900
+f 889 900 908
+f 889 908 907
+f 889 907 917
+f 889 917 909
+f 889 909 901
+f 889 901 891
+f 889 891 892
+f 889 892 893
+f 889 893 894
+f 889 894 895
+f 889 895 896
+f 889 896 904
+f 889 904 897
+f 889 897 898
+f 889 898 890
+f 890 899 900
+f 890 898 899
+f 891 901 912
+f 891 912 919
+f 891 919 926
+f 891 926 933
+f 891 933 930
+f 891 930 938
+f 891 938 942
+f 891 942 948
+f 891 948 955
+f 891 955 962
+f 891 962 972
+f 891 972 979
+f 891 979 986
+f 891 986 993
+f 891 993 1000
+f 891 1000 1009
+f 891 1009 1026
+f 891 1026 1033
+f 891 1033 1034
+f 891 1034 1035
+f 891 1035 1030
+f 891 1030 1019
+f 891 1019 1018
+f 891 1018 1017
+f 891 1017 1016
+f 891 1016 1005
+f 891 1005 997
+f 891 997 991
+f 891 991 985
+f 891 985 977
+f 891 977 969
+f 891 969 960
+f 891 960 951
+f 891 951 943
+f 891 943 939
+f 891 939 934
+f 891 934 927
+f 891 927 920
+f 891 920 913
+f 891 913 902
+f 891 902 895
+f 891 895 894
+f 891 894 893
+f 891 893 892
+f 895 902 903
+f 895 903 904
+f 895 904 896
+f 897 904 905
+f 897 905 898
+f 898 905 914
+f 898 914 921
+f 898 921 928
+f 898 928 935
+f 898 935 940
+f 898 940 945
+f 898 945 953
+f 898 953 959
+f 898 959 968
+f 898 968 976
+f 898 976 984
+f 898 984 992
+f 898 992 999
+f 898 999 1008
+f 898 1008 1024
+f 898 1024 1023
+f 898 1023 1022
+f 898 1022 1014
+f 898 1014 1010
+f 898 1010 1001
+f 898 1001 994
+f 898 994 988
+f 898 988 987
+f 898 987 980
+f 898 980 983
+f 898 983 982
+f 898 982 975
+f 898 975 963
+f 898 963 966
+f 898 966 965
+f 898 965 964
+f 898 964 961
+f 898 961 954
+f 898 954 946
+f 898 946 941
+f 898 941 936
+f 898 936 931
+f 898 931 929
+f 898 929 922
+f 898 922 915
+f 898 915 906
+f 898 906 899
+f 899 906 917
+f 899 917 907
+f 899 907 908
+f 899 908 900
+f 901 909 910
+f 901 910 911
+f 901 911 912
+f 902 913 914
+f 902 914 903
+f 903 914 904
+f 904 914 905
+f 906 915 916
+f 906 916 909
+f 906 909 917
+f 909 916 910
+f 910 916 918
+f 910 918 911
+f 911 919 912
+f 911 918 919
+f 913 920 914
+f 914 920 921
+f 915 922 923
+f 915 923 916
+f 916 923 918
+f 918 923 924
+f 918 924 925
+f 918 925 926
+f 918 926 919
+f 920 927 921
+f 921 927 928
+f 922 929 923
+f 923 929 924
+f 924 930 925
+f 924 929 931
+f 924 931 932
+f 924 932 930
+f 925 933 926
+f 925 930 933
+f 927 934 928
+f 928 934 935
+f 930 932 936
+f 930 936 937
+f 930 937 938
+f 931 936 932
+f 934 939 940
+f 934 940 935
+f 936 941 937
+f 937 941 942
+f 937 942 938
+f 939 943 940
+f 940 943 944
+f 940 944 945
+f 941 946 947
+f 941 947 942
+f 942 947 946
+f 942 946 949
+f 942 949 950
+f 942 950 948
+f 943 951 952
+f 943 952 944
+f 944 952 953
+f 944 953 945
+f 946 954 949
+f 948 950 956
+f 948 956 957
+f 948 957 958
+f 948 958 955
+f 949 954 961
+f 949 961 956
+f 949 956 950
+f 951 959 953
+f 951 953 952
+f 951 960 959
+f 955 958 963
+f 955 963 962
+f 956 961 964
+f 956 964 957
+f 957 964 965
+f 957 965 966
+f 957 966 958
+f 958 966 963
+f 959 960 967
+f 959 967 968
+f 960 969 970
+f 960 970 968
+f 960 968 967
+f 962 971 972
+f 962 963 973
+f 962 973 974
+f 962 974 971
+f 963 975 974
+f 963 974 973
+f 968 970 976
+f 969 977 978
+f 969 978 976
+f 969 976 970
+f 971 974 972
+f 972 974 979
+f 974 980 981
+f 974 981 979
+f 974 975 982
+f 974 982 983
+f 974 983 980
+f 976 978 984
+f 977 985 978
+f 978 985 984
+f 979 981 986
+f 980 987 981
+f 981 987 988
+f 981 988 989
+f 981 989 990
+f 981 990 986
+f 984 985 991
+f 984 991 992
+f 986 990 993
+f 988 994 995
+f 988 995 989
+f 989 995 996
+f 989 996 990
+f 990 996 993
+f 991 997 998
+f 991 998 992
+f 992 998 999
+f 993 996 1000
+f 994 1001 1002
+f 994 1002 995
+f 995 1002 1003
+f 995 1003 996
+f 996 1003 1000
+f 997 1004 998
+f 997 1005 1006
+f 997 1006 1007
+f 997 1007 1004
+f 998 1004 999
+f 999 1004 1008
+f 1000 1003 1009
+f 1001 1010 1002
+f 1002 1011 1027
+f 1002 1027 1028
+f 1002 1028 1020
+f 1002 1020 1032
+f 1002 1032 1029
+f 1002 1029 1015
+f 1002 1015 1012
+f 1002 1012 1003
+f 1002 1010 1013
+f 1002 1013 1014
+f 1002 1014 1011
+f 1003 1012 1015
+f 1003 1015 1009
+f 1004 1007 1008
+f 1005 1016 1006
+f 1006 1016 1017
+f 1006 1017 1018
+f 1006 1018 1019
+f 1006 1019 1007
+f 1007 1019 1020
+f 1007 1020 1021
+f 1007 1021 1022
+f 1007 1022 1023
+f 1007 1023 1024
+f 1007 1024 1008
+f 1009 1015 1025
+f 1009 1025 1026
+f 1010 1014 1013
+f 1011 1014 1027
+f 1014 1022 1028
+f 1014 1028 1027
+f 1015 1029 1025
+f 1019 1030 1031
+f 1019 1031 1032
+f 1019 1032 1020
+f 1020 1028 1021
+f 1021 1028 1022
+f 1025 1029 1033
+f 1025 1033 1026
+f 1029 1032 1031
+f 1029 1031 1034
+f 1029 1034 1033
+f 1030 1035 1031
+f 1031 1035 1034

msx_assets/object/028_skillet_lid/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/065-e_cups/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

msx_assets/object/065-i_cups/material_0.mtl

@@ -0,0 +1,7 @@
+# https://github.com/mikedh/trimesh
+newmtl material_0
+Ka 0.40000000 0.40000000 0.40000000
+Kd 0.40000000 0.40000000 0.40000000
+Ks 0.40000000 0.40000000 0.40000000
+Ns 1.00000000
+map_Kd material_0.png

msx_assets/object/071_nine_hole_peg_test/material_0.mtl

@@ -0,0 +1,7 @@
+# https://github.com/mikedh/trimesh
+newmtl material_0
+Ka 0.40000000 0.40000000 0.40000000
+Kd 0.40000000 0.40000000 0.40000000
+Ks 0.40000000 0.40000000 0.40000000
+Ns 1.00000000
+map_Kd material_0.png

msx_assets/object/073-d_lego_duplo/textured.mtl

@@ -0,0 +1,3 @@
+newmtl material_0
+# shader_type beckmann
+map_Kd texture_map.png

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/layers/__init__.py

@@ -0,0 +1,3 @@
+# from .equiv_layers import *
+from .layers import *
+from .layers_attention import *

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/layers/layers.py

@@ -0,0 +1,504 @@
+import math
+
+import einops
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops.layers.torch import Rearrange
+
+
+## Fully connected Neural Network block - Multi Layer Perceptron
+class MLP(nn.Module):
+    def __init__(self, in_dim, out_dim, hidden_dim=16, n_layers=1, act='relu', batch_norm=True):
+        super(MLP, self).__init__()
+        activations = {'relu': nn.ReLU, 'sigmoid': nn.Sigmoid, 'tanh': nn.Tanh, 'leaky_relu': nn.LeakyReLU,
+                       'elu': nn.ELU, 'prelu': nn.PReLU, 'softplus': nn.Softplus, 'mish': nn.Mish,
+                       'identity': nn.Identity
+                       }
+
+        act_func = activations[act]
+        layers = [nn.Linear(in_dim, hidden_dim), act_func()]
+        for i in range(n_layers):
+            layers += [
+                nn.Linear(hidden_dim, hidden_dim),
+                nn.BatchNorm1d(hidden_dim) if batch_norm else nn.Identity(),
+                act_func(),
+            ]
+        layers.append(nn.Linear(hidden_dim, out_dim))
+
+        self._network = nn.Sequential(
+            *layers
+        )
+
+    def forward(self, x):
+        return self._network(x)
+
+# Identity layer
+class Identity(nn.Module):
+    def __init__(self, ):
+        super(Identity, self).__init__()
+
+    def forward(self, x):
+        return x
+
+
+# Resnet Blocks
+class ResnetBlockFC(nn.Module):
+    '''
+    Fully connected ResNet Block class.
+
+    Args:
+        size_in (int): input dimension
+        size_out (int): output dimension
+        size_h (int): hidden dimension
+    '''
+
+    def __init__(self, size_in, size_out=None, size_h=None):
+        super().__init__()
+        # Attributes
+        if size_out is None:
+            size_out = size_in
+
+        if size_h is None:
+            size_h = min(size_in, size_out)
+
+        self.size_in = size_in
+        self.size_h = size_h
+        self.size_out = size_out
+        # Submodules
+        self.fc_0 = nn.Linear(size_in, size_h)
+        self.fc_1 = nn.Linear(size_h, size_out)
+        self.actvn = nn.ReLU()
+
+        if size_in == size_out:
+            self.shortcut = None
+        else:
+            self.shortcut = nn.Linear(size_in, size_out, bias=False)
+        # Initialization
+        nn.init.zeros_(self.fc_1.weight)
+
+    def forward(self, x):
+        net = self.fc_0(self.actvn(x))
+        dx = self.fc_1(self.actvn(net))
+
+        if self.shortcut is not None:
+            x_s = self.shortcut(x)
+        else:
+            x_s = x
+
+        return x_s + dx
+
+
+class GaussianFourierProjection(nn.Module):
+    """Gaussian random features for encoding time steps."""
+
+    def __init__(self, embed_dim, scale=30.):
+        super().__init__()
+        # Randomly sample weights during initialization. These weights are fixed
+        # during optimization and are not trainable.
+        self.W = nn.Parameter(torch.randn(embed_dim // 2) * scale, requires_grad=False)
+
+    def forward(self, x):
+        x_proj = x[:, None] * self.W[None, :] * 2 * np.pi
+        return torch.cat([torch.sin(x_proj), torch.cos(x_proj)], dim=-1)
+
+
+# https://gist.github.com/kevinzakka/dd9fa5177cda13593524f4d71eb38ad5
+class SpatialSoftArgmax(nn.Module):
+    """Spatial softmax as defined in [1].
+    Concretely, the spatial softmax of each feature
+    map is used to compute a weighted mean of the pixel
+    locations, effectively performing a soft arg-max
+    over the feature dimension.
+    References:
+        [1]: End-to-End Training of Deep Visuomotor Policies,
+        https://arxiv.org/abs/1504.00702
+    """
+
+    def __init__(self, normalize=False):
+        """Constructor.
+        Args:
+            normalize (bool): Whether to use normalized
+                image coordinates, i.e. coordinates in
+                the range `[-1, 1]`.
+        """
+        super().__init__()
+
+        self.normalize = normalize
+
+        self.temperatur = nn.Parameter(torch.ones(1), requires_grad=True)
+
+    def _coord_grid(self, h, w, device):
+        if self.normalize:
+            return torch.stack(
+                torch.meshgrid(
+                    torch.linspace(-1, 1, w, device=device),
+                    torch.linspace(-1, 1, h, device=device),
+                )
+            )
+        return torch.stack(
+            torch.meshgrid(
+                torch.arange(0, w, device=device),
+                torch.arange(0, h, device=device),
+            )
+        )
+
+    def forward(self, x):
+        assert x.ndim == 4, "Expecting a tensor of shape (B, C, H, W)."
+
+        # compute a spatial softmax over the input:
+        # given an input of shape (B, C, H, W),
+        # reshape it to (B*C, H*W) then apply
+        # the softmax operator over the last dimension
+        b, c, h, w = x.shape
+
+        # x = x * h * w
+        x = x * (h * w / self.temperatur)
+        # print(self.temperatur)
+        softmax = F.softmax(x.view(-1, h * w), dim=-1)
+
+        # create a meshgrid of pixel coordinates
+        # both in the x and y axes
+        xc, yc = self._coord_grid(h, w, x.device)
+
+        # element-wise multiply the x and y coordinates
+        # with the softmax, then sum over the h*w dimension
+        # this effectively computes the weighted mean of x
+        # and y locations
+        y_mean = (softmax * xc.flatten()).sum(dim=1, keepdims=True)
+        x_mean = (softmax * yc.flatten()).sum(dim=1, keepdims=True)
+
+        # concatenate and reshape the result
+        # to (B, C*2) where for every feature
+        # we have the expected x and y pixel
+        # locations
+        return torch.cat([x_mean, y_mean], dim=1).view(-1, c * 2)
+
+
+########################################################################################################################
+# Modules Temporal Unet
+########################################################################################################################
+class Residual(nn.Module):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def forward(self, x, *args, **kwargs):
+        return self.fn(x, *args, **kwargs) + x
+
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.fn = fn
+        self.norm = LayerNorm(dim)
+
+    def forward(self, x):
+        x = self.norm(x)
+        return self.fn(x)
+
+
+class LayerNorm(nn.Module):
+    def __init__(self, dim, eps=1e-5):
+        super().__init__()
+        self.eps = eps
+        self.g = nn.Parameter(torch.ones(1, dim, 1))
+        self.b = nn.Parameter(torch.zeros(1, dim, 1))
+
+    def forward(self, x):
+        var = torch.var(x, dim=1, unbiased=False, keepdim=True)
+        mean = torch.mean(x, dim=1, keepdim=True)
+        return (x - mean) / (var + self.eps).sqrt() * self.g + self.b
+
+
+class LinearAttention(nn.Module):
+    def __init__(self, dim, heads=4, dim_head=32):
+        super().__init__()
+        self.scale = dim_head ** -0.5
+        self.heads = heads
+        hidden_dim = dim_head * heads
+        self.to_qkv = nn.Conv1d(dim, hidden_dim * 3, 1, bias=False)
+        self.to_out = nn.Conv1d(hidden_dim, dim, 1)
+
+    def forward(self, x):
+        qkv = self.to_qkv(x).chunk(3, dim = 1)
+        q, k, v = map(lambda t: einops.rearrange(t, 'b (h c) d -> b h c d', h=self.heads), qkv)
+        q = q * self.scale
+
+        k = k.softmax(dim = -1)
+        context = torch.einsum('b h d n, b h e n -> b h d e', k, v)
+
+        out = torch.einsum('b h d e, b h d n -> b h e n', context, q)
+        out = einops.rearrange(out, 'b h c d -> b (h c) d')
+        return self.to_out(out)
+
+
+class TimeEncoder(nn.Module):
+    def __init__(self, dim, dim_out):
+        super().__init__()
+        self.encoder = nn.Sequential(
+            SinusoidalPosEmb(dim),
+            nn.Linear(dim, dim * 4),
+            nn.Mish(),
+            nn.Linear(dim * 4, dim_out)
+        )
+
+    def forward(self, x):
+        return self.encoder(x)
+
+
+class SinusoidalPosEmb(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, x):
+        device = x.device
+        half_dim = self.dim // 2
+        emb = math.log(10000) / (half_dim - 1)
+        emb = torch.exp(torch.arange(half_dim, device=device) * -emb)
+        emb = x[:, None] * emb[None, :]
+        emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
+        return emb
+
+
+class Downsample1d(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.conv = nn.Conv1d(dim, dim, kernel_size=3, stride=2, padding=1)
+
+    def forward(self, x):
+        return self.conv(x)
+
+
+class Upsample1d(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.conv = nn.ConvTranspose1d(dim, dim, kernel_size=4, stride=2, padding=1)
+
+    def forward(self, x):
+        return self.conv(x)
+
+
+class Conv1dBlock(nn.Module):
+    '''
+        Conv1d --> GroupNorm --> Mish
+    '''
+
+    def __init__(self, inp_channels, out_channels, kernel_size, padding=None, n_groups=8):
+        super().__init__()
+        self.block = nn.Sequential(
+            nn.Conv1d(inp_channels, out_channels, kernel_size, stride=1,
+                      padding=padding if padding is not None else kernel_size // 2),
+            Rearrange('batch channels n_support_points -> batch channels 1 n_support_points'),
+            nn.GroupNorm(n_groups, out_channels),
+            Rearrange('batch channels 1 n_support_points -> batch channels n_support_points'),
+            nn.Mish(),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class ResidualBlock(nn.Module):
+    ################
+    # Janner code
+    def __init__(self, in_channels, out_channels, stride=1, downsample=None):
+        super(ResidualBlock, self).__init__()
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU())
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm2d(out_channels))
+        self.downsample = downsample
+        self.relu = nn.ReLU()
+        self.out_channels = out_channels
+
+    def forward(self, x):
+        residual = x
+        out = self.conv1(x)
+        out = self.conv2(out)
+        if self.downsample:
+            residual = self.downsample(x)
+        out += residual
+        out = self.relu(out)
+        return out
+
+
+class ResidualTemporalBlock(nn.Module):
+
+    def __init__(self, inp_channels, out_channels, cond_embed_dim, n_support_points, kernel_size=5):
+        super().__init__()
+
+        self.blocks = nn.ModuleList([
+            Conv1dBlock(inp_channels, out_channels, kernel_size, n_groups=group_norm_n_groups(out_channels)),
+            Conv1dBlock(out_channels, out_channels, kernel_size, n_groups=group_norm_n_groups(out_channels)),
+        ])
+
+        # Without context conditioning, cond_mlp handles only time embeddings
+        self.cond_mlp = nn.Sequential(
+            nn.Mish(),
+            nn.Linear(cond_embed_dim, out_channels),
+            Rearrange('batch t -> batch t 1'),
+        )
+
+        self.residual_conv = nn.Conv1d(inp_channels, out_channels, kernel_size=1, stride=1, padding=0) \
+            if inp_channels != out_channels else nn.Identity()
+
+    def forward(self, x, c):
+        '''
+            x : [ batch_size x inp_channels x n_support_points ]
+            c : [ batch_size x embed_dim ]
+            returns:
+            out : [ batch_size x out_channels x n_support_points ]
+        '''
+        h = self.blocks[0](x) + self.cond_mlp(c)
+        h = self.blocks[1](h)
+        res = self.residual_conv(x)
+        out = h + res
+
+        return out
+
+
+class TemporalBlockMLP(nn.Module):
+
+    def __init__(self, inp_channels, out_channels, cond_embed_dim):
+        super().__init__()
+
+        self.blocks = nn.ModuleList([
+            MLP(inp_channels, out_channels, hidden_dim=out_channels, n_layers=0, act='mish')
+        ])
+
+        # Without context conditioning, cond_mlp handles only time embeddings
+        self.cond_mlp = nn.Sequential(
+            nn.Mish(),
+            nn.Linear(cond_embed_dim, out_channels),
+            # Rearrange('batch t -> batch t 1'),
+        )
+
+        self.last_act = nn.Mish()
+
+    def forward(self, x, c):
+        '''
+            x : [ batch_size x inp_channels x n_support_points ]
+            c : [ batch_size x embed_dim ]
+            returns:
+            out : [ batch_size x out_channels x n_support_points ]
+        '''
+        h = self.blocks[0](x) + self.cond_mlp(c)
+        out = self.last_act(h)
+        return out
+
+
+class FiLMResidualTemporalBlock(ResidualTemporalBlock):
+    def __init__(self, inp_channels, out_channels, cond_embed_dim, n_support_points, kernel_size=5):
+        super().__init__(inp_channels, out_channels, cond_embed_dim, n_support_points, kernel_size)
+        
+        # Replace the original cond_mlp with separate scale and bias MLPs
+        delattr(self, 'cond_mlp')  # Remove the original conditioning MLP
+        
+        self.scale_mlp = nn.Sequential(
+            nn.Mish(),
+            nn.Linear(cond_embed_dim, out_channels),
+            Rearrange('batch t -> batch t 1'),
+        )
+        self.bias_mlp = nn.Sequential(
+            nn.Mish(),
+            nn.Linear(cond_embed_dim, out_channels),
+            Rearrange('batch t -> batch t 1'),
+        )
+
+    def forward(self, x, c):
+        '''
+            x : [ batch_size x inp_channels x n_support_points ]
+            c : [ batch_size x embed_dim ]
+            returns:
+            out : [ batch_size x out_channels x n_support_points ]
+        '''
+        # FiLM conditioning
+        scale = self.scale_mlp(c)
+        bias = self.bias_mlp(c)
+        h = self.blocks[0](x) * scale + bias
+        
+        h = self.blocks[1](h)
+        res = self.residual_conv(x)
+        out = h + res
+        return out
+
+
+def group_norm_n_groups(n_channels, target_n_groups=8):
+    if n_channels < target_n_groups:
+        return 1
+    for n_groups in range(target_n_groups, target_n_groups + 10):
+        if n_channels % n_groups == 0:
+            return n_groups
+    return 1
+
+
+def compute_padding_conv1d(L, KSZ, S, D, deconv=False):
+    '''
+    https://gist.github.com/AhmadMoussa/d32c41c11366440bc5eaf4efb48a2e73
+    :param L:       Input length (or width)
+    :param KSZ:     Kernel size (or width)
+    :param S:       Stride
+    :param D:       Dilation Factor
+    :param deconv:  True if ConvTranspose1d
+    :return:        Returns padding such that output width is exactly half of input width
+    '''
+    print(f"INPUT SIZE {L}")
+    if not deconv:
+        return math.ceil((S * (L / 2) - L + D * (KSZ - 1) - 1) / 2)
+    else:
+        print(L, S, D, KSZ)
+        pad = math.ceil(((L - 1) * S + D * (KSZ - 1) + 1 - L * 2) / 2)
+        print("PAD", pad)
+        output_size = (L - 1) * S - 2 * pad + D * (KSZ - 1) + 1
+        print("OUTPUT SIZE", output_size)
+        return pad
+
+
+def compute_output_length_maxpool1d(L, KSZ, S, D, P):
+    '''
+    https://pytorch.org/docs/stable/generated/torch.nn.MaxPool1d.html
+    :param L:       Input length (or width)
+    :param KSZ:     Kernel size (or width)
+    :param S:       Stride
+    :param D:       Dilation Factor
+    :param P:       Padding
+    '''
+    return math.floor((L + 2 * P - D * (KSZ - 1) - 1) / S + 1)
+
+
+if __name__ == "__main__":
+    b, c, h, w = 1, 64, 12, 12
+    x = torch.full((b, c, h, w), 0.00)
+
+    i_max = 4
+    true_max = torch.randint(0, 10, size=(b, c, 2))
+    for i in range(b):
+        for j in range(c):
+            x[i, j, true_max[i, j, 0], true_max[i, j, 1]] = 1000
+        # x[i, j, i_max, true_max] = 1
+    # x[0,0,0,0] = 1000
+    soft_max = SpatialSoftArgmax(normalize=True)(x)
+    soft_max2 = SpatialSoftArgmax(normalize=False)(x)
+    diff = soft_max - (soft_max2 / 12) * 2 - 1
+    resh = soft_max.reshape(b, c, 2)
+    assert torch.allclose(true_max.float(), resh)
+
+    exit()
+    test_scales = [1, 5, 10, 30, 50, 70, 100]
+    for scale in test_scales[::-1]:
+        i_max = 4
+        true_max = torch.randint(0, 10, size=(b, c, 2))
+        for i in range(b):
+            for j in range(c):
+                x[i, j, true_max[i, j, 0], true_max[i, j, 1]] = scale
+            # x[i, j, i_max, true_max] = 1
+        # x[0,0,0,0] = 1000
+        soft_max = SpatialSoftArgmax(normalize=False)(x)
+        resh = soft_max.reshape(b, c, 2)
+        assert torch.allclose(true_max.float(), resh), scale

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/layers/layers_attention.py

@@ -0,0 +1,194 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops import rearrange, repeat
+from inspect import isfunction
+from torch import einsum
+
+from cfdp.diffusion_policy.layers.layers import group_norm_n_groups
+
+
+def exists(val):
+    return val is not None
+
+
+def uniq(arr):
+    return {el: True for el in arr}.keys()
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+
+def max_neg_value(t):
+    return -torch.finfo(t.dtype).max
+
+
+def init_(tensor):
+    dim = tensor.shape[-1]
+    std = 1 / math.sqrt(dim)
+    tensor.uniform_(-std, std)
+    return tensor
+
+
+# feedforward
+class GEGLU(nn.Module):
+    def __init__(self, dim_in, dim_out):
+        super().__init__()
+        self.proj = nn.Linear(dim_in, dim_out * 2)
+
+    def forward(self, x):
+        x, gate = self.proj(x).chunk(2, dim=-1)
+        return x * F.gelu(gate)
+
+
+class FeedForward(nn.Module):
+    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
+        super().__init__()
+        inner_dim = int(dim * mult)
+        dim_out = default(dim_out, dim)
+        project_in = nn.Sequential(
+            nn.Linear(dim, inner_dim),
+            nn.GELU()
+        ) if not glu else GEGLU(dim, inner_dim)
+
+        self.net = nn.Sequential(
+            project_in,
+            nn.Dropout(dropout),
+            nn.Linear(inner_dim, dim_out)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+def zero_module(module):
+    """
+    Zero out the parameters of a module and return it.
+    """
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+
+
+def Normalize(in_channels):
+    # return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+    return torch.nn.GroupNorm(num_groups=group_norm_n_groups(in_channels), num_channels=in_channels, eps=1e-6,
+                              affine=True)
+
+
+class CrossAttention(nn.Module):
+    def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.):
+        super().__init__()
+        inner_dim = dim_head * heads
+        context_dim = default(context_dim, query_dim)
+
+        self.scale = dim_head ** -0.5
+        self.heads = heads
+
+        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
+
+        self.to_out = nn.Sequential(
+            nn.Linear(inner_dim, query_dim),
+            nn.Dropout(dropout)
+        )
+
+    def forward(self, x, context=None, mask=None):
+        h = self.heads
+
+        q = self.to_q(x)
+        context = default(context, x)
+        k = self.to_k(context)
+        v = self.to_v(context)
+
+        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
+
+        sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
+
+        if exists(mask):
+            mask = rearrange(mask, 'b ... -> b (...)')
+            max_neg_value = -torch.finfo(sim.dtype).max
+            mask = repeat(mask, 'b j -> (b h) () j', h=h)
+            sim.masked_fill_(~mask, max_neg_value)
+
+        # attention, what we cannot get enough of
+        attn = sim.softmax(dim=-1)
+
+        out = einsum('b i j, b j d -> b i d', attn, v)
+        out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
+        return self.to_out(out)
+
+
+class BasicTransformerBlock(nn.Module):
+    def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True):
+        super().__init__()
+        self.attn1 = CrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head,
+                                    dropout=dropout)  # is a self-attention
+        self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
+        self.attn2 = CrossAttention(query_dim=dim, context_dim=context_dim,
+                                    heads=n_heads, dim_head=d_head, dropout=dropout)  # is self-attn if context is none
+        self.norm1 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim)
+        self.norm3 = nn.LayerNorm(dim)
+        self.checkpoint = checkpoint
+
+    def forward(self, x, context=None):
+        # Residual connections and layer normalization
+        x = self.attn1(self.norm1(x)) + x  # self attention
+        x = self.attn2(self.norm2(x), context=context) + x  # attention to context
+        x = self.ff(self.norm3(x)) + x
+        return x
+
+
+class SpatialTransformer(nn.Module):
+    """
+    Transformer block for trajectory-like data.
+    First, project the input (aka embedding)
+    and reshape to b, t, d.
+    Then apply standard transformer action.
+    Finally, reshape to trajectory
+    """
+
+    def __init__(self, in_channels, n_heads, d_head,
+                 depth=1, dropout=0., context_dim=None):
+        super().__init__()
+        self.in_channels = in_channels
+        inner_dim = n_heads * d_head
+        self.norm = Normalize(in_channels)
+
+        # self.proj_in = nn.Conv2d(in_channels,
+        #                          inner_dim,
+        #                          kernel_size=1,
+        #                          stride=1,
+        #                          padding=0)
+        self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
+
+        self.transformer_blocks = nn.ModuleList(
+            [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim)
+             for d in range(depth)]
+        )
+
+        # self.proj_out = zero_module(nn.Conv2d(inner_dim,
+        #                                       in_channels,
+        #                                       kernel_size=1,
+        #                                       stride=1,
+        #                                       padding=0))
+        self.proj_out = zero_module(nn.Conv1d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))
+
+    def forward(self, x, context=None):
+        # note: if no context is given, cross-attention defaults to self-attention
+        b, c, h = x.shape
+        x_in = x
+        x = self.norm(x)
+        x = self.proj_in(x)
+        x = rearrange(x, 'b c h -> b h c')
+        for block in self.transformer_blocks:
+            x = block(x, context=context)
+        x = rearrange(x, 'b h c -> b c h', h=h)
+        x = self.proj_out(x)
+        return x + x_in

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/__init__.py

@@ -0,0 +1,5 @@
+from .diffusion_model_base import GaussianDiffusionModel, build_condition
+from .flow_matching_base import FlowMatchingModel
+from .mlp_model import MLPModel
+from .gaussian_diffusion_loss import FlowMatchingLoss, GaussianDiffusionLoss
+from .temporal_unet import TemporalUnet, ContextModel, PointUnet, UNET_DIM_MULTS

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/diffusion_model_base.py

@@ -0,0 +1,689 @@
+"""
+Adapted from https://github.com/jannerm/diffuser
+"""
+import abc
+import time
+from collections import namedtuple
+from copy import copy
+
+import einops
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.nn as nn
+from abc import ABC
+import time
+from enum import Enum
+
+from torch.nn import DataParallel
+
+from cfdp.diffusion_policy.models.helpers import cosine_beta_schedule, Losses, exponential_beta_schedule
+from cfdp.diffusion_policy.models.sample_functions import extract, apply_hard_conditioning, guide_gradient_steps, \
+    ddpm_sample_fn, ddpm_sample_fn_stomp
+from cfdp.diffusion_policy.utils.utils import to_numpy
+from cfdp.utils.data_utils import interpolate_points, pad_tensor
+
+def make_timesteps(batch_size, i, device):
+    t = torch.full((batch_size,), i, device=device, dtype=torch.long)
+    return t
+
+
+def build_condition(model, dataset, input_dict):
+    # input_dict is already normalized
+    condition = None
+    if model.context_model is not None:
+        condition = dict()
+        task_normalized = input_dict[f'{dataset.data_key_task}_normalized']
+
+        # (normalized) features of variable environments
+        # if hasattr(dataset, 'variable_environment') and dataset.variable_environment:
+        #     env_normalized = input_dict[f'{dataset.field_key_env}_normalized']
+        #     condition['env'] = env_normalized
+        # obs_history
+        # breakpoint()
+        if hasattr(dataset, 'data_key_obs_history'): # TODO: Make it better...
+            obs_history = input_dict[f'{dataset.data_key_obs_history}_normalized']
+            # breakpoint()
+            condition['tasks'] = torch.cat((task_normalized, obs_history), dim = -1)
+            # breakpoint()
+        else:
+            condition['tasks'] = task_normalized
+    return condition
+
+class PredictionMode(Enum):
+    EPSILON = "epsilon"
+    V = "v"
+    X = "x"
+
+class GaussianDiffusionModel(nn.Module, ABC):
+
+    def __init__(self,
+                 model=None,
+                 variance_schedule='exponential',
+                 n_diffusion_steps=100,
+                 clip_denoised=True,
+                 prediction_mode="epsilon", # Accept string: "epsilon", "v", "x"
+                 use_snr_weight=False, #snr weight for training loss function
+                 loss_type='l2',
+                 context_model=None,
+                 device='cuda',
+                 **kwargs):
+        super().__init__()
+
+        self.model_name = 'DiffusionModel'
+
+        self.model = model
+
+        self.context_model = context_model
+
+        self.n_diffusion_steps = n_diffusion_steps
+
+        self.state_dim = self.model.state_dim
+
+        self.device = device
+        # debug information dispay
+        self.verbose = False
+        self.use_snr_weight = use_snr_weight
+
+        if variance_schedule == 'cosine':
+            betas = cosine_beta_schedule(n_diffusion_steps, s=0.008, a_min=0, a_max=0.999)
+        elif variance_schedule == 'exponential':
+            betas = exponential_beta_schedule(n_diffusion_steps, beta_start=1e-4, beta_end=1.0)
+        else:
+            raise NotImplementedError
+
+        alphas = 1. - betas
+        alphas_cumprod = torch.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = torch.cat([torch.ones(1), alphas_cumprod[:-1]])
+
+        # print("betas shape: ", betas.shape)
+        # print("alpha shape: ", alphas.shape)
+        # print("alphas_cumprod_prev shape: ", alphas_cumprod_prev.shape)
+        # print("betas: ", betas)
+        # print("alphas:  ", alphas)
+        # print("alphas_cumprod_prev: ", alphas_cumprod_prev)
+       
+        self.clip_denoised = clip_denoised
+        # self.predict_epsilon = predict_epsilon
+        if isinstance(prediction_mode, str):
+            self.prediction_mode = PredictionMode(prediction_mode.lower())
+        elif isinstance(prediction_mode, PredictionMode):
+            self.prediction_mode = prediction_mode
+        else:
+            raise ValueError(f"Invalid prediction_mode: {prediction_mode}")
+
+        self.register_buffer('betas', betas)
+        self.register_buffer('alphas_cumprod', alphas_cumprod)
+        self.register_buffer('alphas_cumprod_prev', alphas_cumprod_prev)
+
+        # calculations for diffusion q(x_t | x_{t-1}) and others
+        self.register_buffer('sqrt_alphas_cumprod', torch.sqrt(alphas_cumprod))
+        self.register_buffer('sqrt_one_minus_alphas_cumprod', torch.sqrt(1. - alphas_cumprod))
+        self.register_buffer('log_one_minus_alphas_cumprod', torch.log(1. - alphas_cumprod))
+        self.register_buffer('sqrt_recip_alphas_cumprod', torch.sqrt(1. / alphas_cumprod))
+        self.register_buffer('sqrt_recipm1_alphas_cumprod', torch.sqrt(1. / alphas_cumprod - 1))
+
+        # calculations for posterior q(x_{t-1} | x_t, x_0)
+        posterior_variance = betas * (1. - alphas_cumprod_prev) / (1. - alphas_cumprod)
+        self.register_buffer('posterior_variance', posterior_variance)
+
+        ## log calculation clipped because the posterior variance
+        ## is 0 at the beginning of the diffusion chain
+        self.register_buffer('posterior_log_variance_clipped',
+                             torch.log(torch.clamp(posterior_variance, min=1e-20)))
+        self.register_buffer('posterior_mean_coef1',
+                             betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod))
+        self.register_buffer('posterior_mean_coef2',
+                             (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod))
+
+        ## get loss coefficients and initialize objective
+        self.loss_fn = Losses[loss_type]()
+
+        # Initialize list to store diffusion process data (for vissualization usage)
+        self.diffusion_history = []
+        self.grad_scaled_history = []
+    # ------------------------------------------ sampling ------------------------------------------#
+    def predict_noise_from_start(self, x_t, t, x0):
+        """
+        Model output can be 'epsilon', 'v', or 'x'
+        """
+        if self.prediction_mode == PredictionMode.EPSILON:
+            return x0
+        elif self.prediction_mode == PredictionMode.X:
+            return (
+                extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - x0
+            ) / extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
+        elif self.prediction_mode == PredictionMode.V:
+            # model predicts v; convert to epsilon:
+            # eps = sqrt(alpha_bar) * v + sqrt(1 - alpha_bar) * x_t
+            sqrt_ab = extract(self.sqrt_alphas_cumprod, t, x_t.shape)
+            sqrt_1mab = extract(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape)
+            v = x0
+            return sqrt_ab * v + sqrt_1mab * x_t
+        else:
+            raise ValueError(f"Unknown prediction_mode: {self.prediction_mode}")
+
+    def predict_start_from_noise(self, x_t, t, noise):
+        '''
+        Model output can be 'epsilon', 'v', or 'x'
+        '''
+        if self.prediction_mode == PredictionMode.EPSILON:
+            return (
+                extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
+                extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
+            )
+        elif self.prediction_mode == PredictionMode.X:
+            return noise
+        elif self.prediction_mode == PredictionMode.V:
+            # model predicts v; convert to x0:
+            # x0 = sqrt(ᾱ)*x_t - sqrt(1-ᾱ)*v
+            sqrt_ab  = extract(self.sqrt_alphas_cumprod, t, x_t.shape)
+            sqrt_1mab = extract(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape)
+            v = noise
+            return sqrt_ab * x_t - sqrt_1mab * v
+        else:
+            raise ValueError(f"Unknown prediction_mode: {self.prediction_mode}")
+
+    def q_posterior(self, x_start, x_t, t):
+        posterior_mean = (
+                extract(self.posterior_mean_coef1, t, x_t.shape) * x_start +
+                extract(self.posterior_mean_coef2, t, x_t.shape) * x_t
+        )
+        posterior_variance = extract(self.posterior_variance, t, x_t.shape)
+        posterior_log_variance_clipped = extract(self.posterior_log_variance_clipped, t, x_t.shape)
+        return posterior_mean, posterior_variance, posterior_log_variance_clipped
+
+    def p_mean_variance(self, x, hard_conds, context, t):
+        if context is not None:
+            context = self.context_model(context)
+
+        x_recon = self.predict_start_from_noise(x, t=t, noise=self.model(x, t, context['condition']))
+        # Store the current state, timestep, and reconstruction
+        # todo: hack here maybe, loop all x from -1 to 1
+        if self.clip_denoised:
+            x_recon.clamp_(-1., 1.)
+        else:
+            assert RuntimeError()
+
+        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
+        return model_mean, posterior_variance, posterior_log_variance
+
+    @torch.no_grad()
+    def p_sample_loop(self, shape,
+                    hard_conds, 
+                    context = None, 
+                    return_chain = False,
+                    sample_fn = ddpm_sample_fn,
+                    n_diffusion_steps_without_noise = 0,
+                    prior_trajectory = None,
+                    timestep = None,
+                    **sample_kwargs):
+        device = self.betas.device
+
+        batch_size = shape[0]
+        n_diffusion_steps = self.n_diffusion_steps # Number of diffusion timesteps.
+        # If given prior trajectory to replan, then use the timestep provided.
+        if prior_trajectory is not None:
+            # Expand prior trajectory to match batch size if needed
+            x = prior_trajectory.repeat(batch_size, 1, 1)
+            n_diffusion_steps = timestep
+        else:
+            x = torch.randn(shape, device=device)
+        
+        # print("In function p_sample_loop. Printing x.shape: ", x.shape)
+        # breakpoint()
+        x = apply_hard_conditioning(x, hard_conds)
+        chain = [x] if return_chain else None
+        for i in reversed(range(n_diffusion_steps_without_noise, n_diffusion_steps)):
+            t = make_timesteps(batch_size, i, device)
+            x, values = sample_fn(self, x, hard_conds, context, t, **sample_kwargs)
+            x = apply_hard_conditioning(x, hard_conds)
+            if return_chain:
+                chain.append(x)
+            
+        if return_chain:
+            chain = torch.stack(chain, dim=1)
+            return x, chain
+        print("x min:", x.min().item(), "x max:", x.max().item())
+        print("hard_conds: ", hard_conds)
+        return x
+
+    def eta_schedule(self, t_norm: torch.Tensor):
+        # t_norm in [0,1], 1=early, 0=late
+        # e.g., cosine ramp: more noise early, near-zero late
+        # return 0.5 * (1 - torch.cos(torch.pi * t_norm))  # in [0,1]
+        base = 0.5 * (1 - torch.cos(torch.pi * t_norm))
+        res = base**20.0
+        # if res < 0.2:
+        #     res = torch.tensor(0.2, device=t_norm.device)
+        return res
+
+    @torch.no_grad()
+    def _ddim_step_core(self, x_t, t, t_next, context, eta_t,
+                    x0_override_fn=None):
+        # model forward
+        model_out = self.model(x_t, t, context['condition'])
+        # 2) x0 from model_out
+        x0 = self.predict_start_from_noise(x_t, t=t, noise=model_out)
+        x0.clamp_(-1., 1.)
+        # 3) optional late-stage overwrite on x0
+        if x0_override_fn is not None:
+            x0_new = x0_override_fn(x0)  # may return x0 or blended x0
+            if x0_new is not None:
+                x0 = x0_new
+            #     x0 = apply_hard_conditioning(x0, hard_conds=None)  # or pass hard_conds via closure
+        # 4) compute epsilon consistent with (possibly) updated x0
+        #    default: from model_out (handles EPS/X/V)
+        pred_noise = self.predict_noise_from_start(x_t, t=t, x0=model_out)
+
+        if self.verbose:
+                print("noise diff:", (model_out - pred_noise).abs().mean().item())
+        # 5) last step or DDIM update
+        if (t_next < 0).all():
+            x_next = x0
+        else:
+            alpha      = extract(self.alphas_cumprod, t, x_t.shape)
+            alpha_next = extract(self.alphas_cumprod, t_next, x_t.shape)
+            sigma = (
+                eta_t * ((1 - alpha / alpha_next) * (1 - alpha_next) / (1 - alpha)).sqrt())
+            c = (1 - alpha_next - sigma**2).sqrt()
+            # breakpoint()
+            x_next = x0 * alpha_next.sqrt() + c * pred_noise
+            x_next = x_next + sigma * torch.randn_like(x_next)
+        return x_next, x0, model_out
+
+    @torch.no_grad()
+    def ddim_sample(
+        self, 
+        shape, 
+        hard_conds,
+        full_time_series=None,
+        start_timestep = None,
+        prior_trajectory = None,
+        context = None, 
+        return_chain = False,
+        # t_start_guide = torch.inf,
+        # guide = None,
+        # n_guide_steps = 1,
+        **sample_kwargs,
+    ):
+        # Adapted from https://github.com/ezhang7423/language-control-diffusion/blob/63cdafb63d166221549968c662562753f6ac5394/src/lcd/models/diffusion.py#L226
+        device = self.betas.device
+        batch_size = shape[0]
+
+        if full_time_series is None:
+            total_timesteps = self.n_diffusion_steps
+            sampling_timesteps = self.n_diffusion_steps // 4
+            full_time_series = torch.linspace(0, total_timesteps - 1, steps=sampling_timesteps + 1, device=device)
+            full_time_series = torch.cat((torch.tensor([-1], device=device), full_time_series))
+        
+        # sampling_timesteps = self.n_diffusion_steps // 4
+        # # [-1, 0, 1, 2, ..., T-1] when sampling_timesteps == total_timesteps
+        if start_timestep is not None: # denoising from intermidiate timestep
+            times = full_time_series[full_time_series <= start_timestep].int().tolist()
+            times = list(reversed(times)) 
+            time_pairs = list(zip(times[:-1], times[1:]))
+        else:
+            times = list(reversed(full_time_series.int().tolist()))
+            time_pairs = list(zip(times[:-1], times[1:]))  # [(T-1, T-2), (T-2, T-3), ..., (1, 0), (0, -1)]
+
+        if self.verbose:
+            print("full time series: ", full_time_series)
+            print("time pairs: ", time_pairs)
+            print("whole time steps for DDIM sampling: ", len(time_pairs))
+        
+        if start_timestep is not None and prior_trajectory is not None:
+            x = prior_trajectory
+        else:
+            x = torch.randn(shape, device=device)
+            x = apply_hard_conditioning(x, hard_conds)
+
+        chain = [x] if return_chain else None
+        
+        if context is not None:
+            context = self.context_model(context)
+
+        for time, time_next in time_pairs:
+            t = make_timesteps(batch_size, time, device)
+            t_next = make_timesteps(batch_size, time_next, device)
+
+            # eta_t
+            t_norm = (time + 1e-8) / (total_timesteps - 1 + 1e-8)          # ~1 at start, 0 at end
+            eta_t = self.eta_schedule(torch.tensor(t_norm, device=device))
+            # eta_t = 0
+            x, x0, _ = self._ddim_step_core(
+                    x, t, t_next, context, eta_t,
+                    x0_override_fn=None
+            )
+
+            x = apply_hard_conditioning(x, hard_conds)
+
+            if return_chain: chain.append(x)
+            if (time_next < 0): break
+        
+        if return_chain:
+            chain = torch.stack(chain, dim=1)
+            return x, chain
+        return x
+    
+    @torch.no_grad()
+    def ddim_sample_with_guidance(
+        self,
+        shape,
+        hard_conds,
+        return_chain=False,
+        guide=None,
+        rank_fn=None,
+        start_timestep = None,
+        prior_trajectory = None,
+        context = None, 
+        sampling_timesteps=None,
+        **sample_kwargs,
+    ):
+        device = self.betas.device
+        batch_size = shape[0]
+        eta = 0
+        total_timesteps = self.n_diffusion_steps
+        sampling_timesteps = sampling_timesteps or total_timesteps // 4
+
+        if "t_start_guide" in sample_kwargs:
+            t_start_guide = sample_kwargs["t_start_guide"]
+            print("t_start_guide =", t_start_guide)
+        else:
+            print("No t_start_guide provided, t_start_guide = 3")
+            t_start_guide = 3
+
+        # ======== Construct Time Schedule ========
+        full_time_series = torch.linspace(0, total_timesteps - 1, 
+                                            steps=sampling_timesteps + 1, 
+                                            device=device)
+        full_time_series = torch.cat((torch.tensor([-1], device=device), full_time_series))
+        # middle_t = full_time_series[2].item()  # e.g., 2nd step from end
+        # middle_timesteps = make_timesteps(shape[0], middle_t, device)
+        # sampling_timesteps = self.n_diffusion_steps // 4
+        # # [-1, 0, 1, 2, ..., T-1] when sampling_timesteps == total_timesteps
+        if start_timestep is not None: # denoising from intermidiate timestep
+            times = full_time_series[full_time_series <= start_timestep].int().tolist()
+            times = list(reversed(times)) 
+            time_pairs = list(zip(times[:-1], times[1:]))
+        else:
+            times = list(reversed(full_time_series.int().tolist()))
+            time_pairs = list(zip(times[:-1], times[1:]))  # [(T-1, T-2), (T-2, T-3), ..., (1, 0), (0, -1)]
+
+        # use guidance to overwrite x, or not apply guidance
+        def apply_rank_or_inpaint(x, t):
+            if rank_fn is None:
+                return x
+            # return rank_fn.rank_trajectory(x, traj_type="ee")
+            if t < 1:
+                if self.verbose:
+                    print("Applying rank function", type(rank_fn))
+                return rank_fn.rank_trajectory(x, traj_type="ee")
+            else:
+                if self.verbose:
+                    print("Applying inpaint function", type(rank_fn))
+                return rank_fn.inpaint_trajectory(x, traj_type="ee", num_windows=4, top_k=3)
+
+        def make_override_fn(step_or_t):
+            def _fn(x0):
+                # Add guidance gradients
+                x_over, _ = guide_gradient_steps(
+                    x0, hard_conds=hard_conds, guide=guide, **sample_kwargs)
+                # x_over = apply_hard_conditioning(x_over, hard_conds)
+                x_over = apply_rank_or_inpaint(x_over, step_or_t)
+                x_over = apply_hard_conditioning(x_over, hard_conds)
+                return x_over
+            return _fn
+
+        # ======== Initialize Trajectory ========
+        # x = torch.randn(shape, device=device) #or read from prior_trajectory
+        if start_timestep is not None and prior_trajectory is not None:
+            x = prior_trajectory
+        else:
+            x = torch.randn(shape, device=device)
+            x = apply_hard_conditioning(x, hard_conds)
+
+        # ======== Iterative Sampling + Guidance ========
+        if rank_fn is not None: rank_fn.reset()
+        chain = [x] if return_chain else None
+        
+        if context is not None:
+            context = self.context_model(context)
+
+        for time, time_next in time_pairs:
+            t = make_timesteps(batch_size, time, device)
+            t_next = make_timesteps(batch_size, time_next, device)
+
+            override_fn = make_override_fn(time) if (guide is not None and time <= t_start_guide) else None
+            # eta_t
+            t_norm = (time + 1e-8) / (total_timesteps - 1 + 1e-8)          # ~1 at start, 0 at end
+            eta_t = self.eta_schedule(torch.tensor(t_norm, device=device))
+            # eta_t = 0
+            x, x0, _ = self._ddim_step_core(
+                x, t, t_next, context, eta_t,
+                x0_override_fn=override_fn)
+
+            x = apply_hard_conditioning(x, hard_conds)
+
+            if return_chain: chain.append(x)
+            if (time_next < 0): break
+        
+        if return_chain:
+            chain = torch.stack(chain, dim=1)
+            return x, chain
+        return x
+
+    @torch.no_grad()
+    def conditional_sample(self, 
+                        hard_conds, 
+                        horizon = None, 
+                        batch_size = 1, 
+                        ddim = False, 
+                        prior_trajectory = None, 
+                        timestep = None, 
+                        **sample_kwargs):
+        '''
+            hard conditions : hard_conds : { (time, state), ... }
+        '''
+        horizon = horizon or self.horizon
+        shape = (batch_size, horizon, self.state_dim)
+
+
+        if self.verbose:
+            print("-------use DDIM------", ddim)
+        if ddim:
+            return self.ddim_sample_with_guidance(shape, hard_conds, sampling_timesteps=self.n_diffusion_steps, **sample_kwargs)
+            # return self.ddim_sample(shape, hard_conds, sampling_timesteps=self.n_diffusion_steps, **sample_kwargs)
+        return self.p_sample_loop(shape, 
+                                hard_conds, 
+                                prior_trajectory = prior_trajectory, 
+                                timestep = timestep, 
+                                **sample_kwargs)
+
+    def forward(self, cond, *args, **kwargs):
+        raise NotImplementedError
+        return self.conditional_sample(cond, *args, **kwargs)
+
+    @torch.no_grad()
+    def warmup(self, horizon=64, device='cuda'):
+        shape = (2, horizon, self.state_dim)
+        x = torch.randn(shape, device=device)
+        t = make_timesteps(2, 1, device)
+        self.model(x, t, context=None)
+
+    @torch.no_grad()
+    def run_inference(self, context=None, hard_conds=None, n_samples=1, return_chain=False, **diffusion_kwargs):
+        # clear diffusion history record
+        self.diffusion_history = []
+        self.grad_scaled_history = []
+
+        # context and hard_conds must be normalized
+        hard_conds = copy(hard_conds)
+        context = copy(context)
+
+        # repeat hard conditions and contexts for n_samples
+        for k, v in hard_conds.items():
+            new_state = einops.repeat(v.to(self.device), 'd -> b d', b=n_samples)
+            hard_conds[k] = new_state
+
+        if context is not None:
+            for k, v in context.items():
+                context[k] = einops.repeat(v.to(self.device), 'd -> b d', b=n_samples)
+
+        # Sample from diffusion model
+        samples, chain = self.conditional_sample(
+            hard_conds, context=context, batch_size=n_samples, return_chain=True, **diffusion_kwargs
+        )
+
+        # chain: [ n_samples x (n_diffusion_steps + 1) x horizon x (state_dim)]
+        # extract normalized trajectories
+        trajs_chain_normalized = chain
+
+        # trajs: [ (n_diffusion_steps + 1) x n_samples x horizon x state_dim ]
+        trajs_chain_normalized = einops.rearrange(trajs_chain_normalized, 'b diffsteps h d -> diffsteps b h d')
+
+        if return_chain:
+            return trajs_chain_normalized
+
+        # return the last denoising step
+        return trajs_chain_normalized[-1]
+
+    @torch.no_grad()
+    def run_inference_with_replanning(self, 
+                                    context = None, 
+                                    hard_conds = None,
+                                    n_samples = 1, 
+                                    return_chain = False, 
+                                    trajectory_prior = None, 
+                                    choice: str = None, 
+                                    trajectory_length: int = None, 
+                                    timestep: int = None, 
+                                    **diffusion_kwargs):
+        # clear diffusion history record
+        self.diffusion_history = []
+        self.grad_scaled_history = []
+        # Extract the trajectory to replan from the prior trajectory.
+        if len(trajectory_prior.shape) == 2:
+            trajectory_prior = trajectory_prior.unsqueeze(0)
+        trajectory_prior = trajectory_prior.to(self.device)
+        trajectory = trajectory_prior
+        if choice == 'pad':
+            # Pad the trajectory to the original length
+            trajectory = pad_tensor(trajectory.squeeze(0), trajectory_length, pad_front = False).unsqueeze(0)
+        elif choice == 'interpolate':
+            # Interpolate the trajectory to the original length
+            trajectory = interpolate_points(trajectory, trajectory_length, resample=True)
+        else:
+            raise ValueError(f"Invalid choice: {choice}")       
+        # print("After Interpolation/Padding Trajectory Shape: ", trajectory.shape)
+        # breakpoint()
+
+        # Add noise for replanning:
+        timesteps = torch.full((trajectory.shape[0],), timestep, device=trajectory.device) # Convert timestep to tensor and expand to match batch dimension
+        traj_noisy = self.q_sample(x_start=trajectory, t=timesteps, noise=torch.randn_like(trajectory))
+
+        # context and hard_conds must be normalized
+        hard_conds = copy(hard_conds)
+        context = copy(context)
+
+        # repeat hard conditions and contexts for n_samples
+        for k, v in hard_conds.items():
+            new_state = einops.repeat(v.to(self.device), 'd -> b d', b=n_samples)
+            hard_conds[k] = new_state
+
+        if context is not None:
+            for k, v in context.items():
+                context[k] = einops.repeat(v.to(self.device), 'd -> b d', b=n_samples)
+
+        # Sample from diffusion model
+        samples, chain = self.conditional_sample(
+            hard_conds, 
+            context = context, 
+            batch_size = n_samples, 
+            return_chain =True, 
+            prior_trajectory=traj_noisy, 
+            timestep=timestep, 
+            **diffusion_kwargs
+        )
+
+        # chain: [ n_samples x (n_diffusion_steps + 1) x horizon x (state_dim)]
+        # extract normalized trajectories
+        trajs_chain_normalized = chain
+
+        # trajs: [ (n_diffusion_steps + 1) x n_samples x horizon x state_dim ]
+        trajs_chain_normalized = einops.rearrange(trajs_chain_normalized, 'b diffsteps h d -> diffsteps b h d')
+
+        if return_chain:
+            return trajs_chain_normalized
+
+        # return the last denoising step
+        return trajs_chain_normalized[-1]
+    # ------------------------------------------ training ------------------------------------------#
+
+    def q_sample(self, x_start, t, noise=None):
+        if noise is None:
+            noise = torch.randn_like(x_start)
+
+        sample = (
+                extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
+                extract(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise
+        )
+        return sample
+
+    def p_losses(self, x_start, context, t, hard_conds):
+        noise = torch.randn_like(x_start)
+
+        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
+        x_noisy = apply_hard_conditioning(x_noisy, hard_conds)
+
+        # context model
+        if context is not None:
+            context = self.context_model(context)
+
+        # diffusion model
+        x_recon = self.model(x_noisy, t, context['condition'])
+        x_recon = apply_hard_conditioning(x_recon, hard_conds)
+
+        assert noise.shape == x_recon.shape
+
+        if self.prediction_mode == PredictionMode.EPSILON:
+            loss, info = self.loss_fn(x_recon, noise)
+        elif self.prediction_mode == PredictionMode.X:
+            loss, info = self.loss_fn(x_recon, x_start)
+        elif self.prediction_mode == PredictionMode.V:
+            # model outputs v-hat; build v_target = sqrt(ab)*eps - sqrt(1-ab)*x0
+            sqrt_ab   = extract(self.sqrt_alphas_cumprod, t, x_start.shape) # sqrt(ᾱ_t)
+            sqrt_1mab = extract(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) # sqrt(1-ᾱ_t)
+            v_target = sqrt_ab * noise - sqrt_1mab * x_start  # v = sqrt(ab)*eps - sqrt(1-ab)*x0
+            
+            # Option A: plain loss via your loss_fn (assumed MSE)
+            if not self.use_snr_weight:
+                loss, info = self.loss_fn(x_recon, v_target)
+            # Option B: SNR-weighted MSE (recommended for v-pred)
+            # refer to paper: PROGRESSIVE DISTILLATION FOR FAST SAMPLING OF DIFFUSION MODELS
+            # reduce weight of high noise area
+            else:
+                # SNR_t = ᾱ_t / (1-ᾱ_t)
+                ab = sqrt_ab ** 2
+                snr = ab / (1.0 - ab).clamp(min=1e-8)
+                w = snr / (snr + 1.0)  # stable reweighting
+                # match dims for broadcasting (B -> Bx1x...):
+                while w.ndim < v_target.ndim:
+                    w = w.unsqueeze(-1)
+                mse = (x_recon - v_target).pow(2)
+                loss = (w * mse).mean()
+                info = {
+                    "snr_weighted": True,
+                    "snr_mean": snr.mean().item(),
+                    "mse_mean": mse.mean().item(),
+                }
+        else:
+            raise ValueError(f"Unknown prediction_mode: {self.prediction_mode}")
+
+        return loss, info
+
+    def loss(self, x, context, *args):
+        batch_size = x.shape[0]
+        t = torch.randint(0, self.n_diffusion_steps, (batch_size,), device=x.device).long()
+        return self.p_losses(x, context, t, *args)
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/flow_matching_base.py

@@ -0,0 +1,129 @@
+from copy import copy
+
+import einops
+import torch
+import torch.nn as nn
+from abc import ABC
+
+from cfdp.diffusion_policy.models.sample_functions import apply_hard_conditioning
+
+class FlowMatchingModel(nn.Module, ABC):
+    def __init__(self,
+                 model=None,
+                 nonuniform_time=False,  # Use sigmoid-transformed normal distribution for time sampling
+                 context_model=None,
+                 device='cuda',
+                 **kwargs):
+        super().__init__()
+        self.model_name = 'FlowMatchingModel'
+        self.model = model # Unet model
+        self.nonuniform_time = nonuniform_time
+        self.context_model = context_model
+        self.state_dim = self.model.state_dim
+        self.device = device
+
+    def forward(self, x, hard_conds, context):
+        # x, action 
+        # hard_conds, start & goal hard constraints
+        # context, task-specific conditioning, environment observation
+        b = x.size(0)
+        if self.nonuniform_time:
+            # Sample time values from sigmoid-transformed normal distribution
+            nt = torch.randn((b,)).to(x.device)
+            t = torch.sigmoid(nt)
+        else:
+            # Sample time values uniformly from [0,1]
+            t = torch.rand((b,)).to(x.device)
+        texp = t.view([b, *([1] * len(x.shape[1:]))])
+        z1 = torch.randn_like(x)
+        z1 = apply_hard_conditioning(z1, hard_conds)
+        zt = (1 - texp) * x + texp * z1
+        
+
+        if context is not None:
+            context = self.context_model(context)
+        # match input & outpu & conditions
+        vtheta = self.model(zt, t, context['condition'])
+
+        batchwise_mse = ((z1 - x - vtheta) ** 2).mean(dim=list(range(1, len(x.shape))))
+        tlist = batchwise_mse.detach().cpu().reshape(-1).tolist()
+        ttloss = [(tv, tloss) for tv, tloss in zip(t, tlist)]
+        return batchwise_mse.mean(), ttloss
+
+    @torch.no_grad()
+    def warmup(self, horizon=64, device='cuda'):
+        shape = (2, horizon, self.state_dim)
+        x = torch.randn(shape, device=device)
+        t = torch.full((2,), 1, device=device, dtype=torch.long)
+        self.model(x, t, context=None)
+
+    @torch.no_grad()
+    def run_inference(self, context=None, hard_conds=None, n_samples=1, return_chain=False, **inference_kwargs):
+        # hard_conds and context must be normalized
+        hard_conds = copy(hard_conds)
+        context = copy(context)
+        # repeat hard conditions and contexts for n_samples
+        for k, v in hard_conds.items():
+            new_state = einops.repeat(v.to(self.device), 'd -> b d', b=n_samples)
+            hard_conds[k] = new_state
+
+        if context is not None:
+            for k, v in context.items():
+                context[k] = einops.repeat(v.to(self.device), 'd -> b d', b=n_samples)
+        
+        # Sample from flow matching model
+        # TODO: sample z in x dimension [b, T, state_dim]
+        trajs_chain = self.sample(hard_conds = hard_conds, context = context, 
+                                  batch_size = n_samples, **inference_kwargs)
+        
+        # trajs_chain is a list of tensors, each with shape (b, T, state_dim)
+        if return_chain:
+            # Stack along first dimension to get (sample_steps+1, b, T, state_dim)
+            trajs_chain = torch.stack(trajs_chain, dim=0)
+            return trajs_chain
+        else:
+            return trajs_chain[-1]
+        
+        
+
+    @torch.no_grad()
+    def sample(self, hard_conds, horizon=None, context=None, 
+               batch_size=1, null_cond=None, sample_steps=5, cfg=2.0, guide=None, **inference_kwargs):
+        z = torch.randn(batch_size, horizon, self.state_dim).to(self.device)
+        b = batch_size
+        dt = 1.0 / sample_steps
+        dt = torch.tensor([dt] * b).to(z.device).view([b, *([1] * len(z.shape[1:]))])
+        trajs_chain = [z]
+        print("guide function is: ", guide)
+        # TODO: add guidance will totally ruin the flow
+        
+
+        for i in range(sample_steps, 0, -1): 
+            t = i / sample_steps
+            t = torch.tensor([t] * b).to(z.device)
+            
+            if context is not None:
+                conidtion = self.context_model(context)
+
+            vc = self.model(z, t, conidtion['condition'])
+
+            # if null_cond is not None:
+            #     vu = self.model(z, t, null_cond)
+            #     vc = vu + cfg * (vc - vu)
+
+            # if i<=3 and guide is not None:
+            #     vu = 200*guide(z)
+            #     vc_norm = torch.norm(vc)
+            #     vu_norm = torch.norm(vu)
+            #     norm_ratio = vc_norm / vu_norm
+            #     print(f"Norm ratio (vc/vu): {norm_ratio:.4f}")
+            #     vc = (1-0.05) * vc + 0.05 * vu
+            
+            z = z - dt * vc
+            z = apply_hard_conditioning(z, hard_conds)
+            trajs_chain.append(z)
+        
+        return trajs_chain
+        
+
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/gaussian_diffusion_loss.py

@@ -0,0 +1,52 @@
+import torch
+from cfdp.diffusion_policy.models import build_condition
+
+
+class GaussianDiffusionLoss:
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def loss_fn(diffusion_model, input_dict, dataset, step=None):
+        """
+        Loss function for training diffusion-based generative models.
+        """
+        # traj_normalized = input_dict[f'{dataset.field_key_traj}_normalized']
+
+        traj_normalized = input_dict[f'{dataset.data_key_traj}_normalized']
+
+        condition = build_condition(diffusion_model, dataset, input_dict)
+
+        hard_conds = input_dict.get('hard_conds', {})
+        # print("hard_conds: ", hard_conds)
+        # print("trajectory normalized shape: ", traj_normalized.shape)
+        # print("trajectory normalized start: ", traj_normalized[0])
+        loss, info = diffusion_model.loss(traj_normalized, condition, hard_conds)
+
+        loss_dict = {'diffusion_loss': loss}
+
+        return loss_dict, info
+
+
+class FlowMatchingLoss:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def loss_fn(model, input_dict, dataset, step=None):
+        """
+        Loss function for training diffusion-based generative models.
+        """
+        traj_normalized = input_dict[f'{dataset.data_key_traj}_normalized']
+
+        condition = build_condition(model, dataset, input_dict)
+
+        hard_conds = input_dict.get('hard_conds', {})
+ 
+        loss, _ = model(traj_normalized, hard_conds, condition)
+        # loss, info = diffusion_model.loss(traj_normalized, context, hard_conds)
+
+        loss_dict = {'diffusion_loss': loss}
+
+        return loss_dict, _

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/guide_managers.py

@@ -0,0 +1,1636 @@
+import abc
+import time
+from dataclasses import dataclass, field
+
+from typing import Dict, List
+import einops
+import numpy as np
+import sapien
+import torch
+from enum import Enum
+import math
+from torch import nn
+import torch.nn.functional as F
+
+from cfdp.utils.pointcloud_sdf import PointCloud_CSDF
+from cfdp.utils.data_utils import transform_ortho6d_to_quat
+from cfdp.utils.advanced_kinematics_solver import AdvancedKinematicsSolver
+
+@dataclass
+class DebugEntry: #for sphere based guidance debug
+    sphere_poses: any = None
+    sphere_radii: any = None
+    sdf_costs: any = None
+    spheres_after_guidance: any = None
+    sampled_spheres: any = None
+
+class SampleHelper:
+    # can be expand to Gaussian / spline sampling
+    # define input and output
+    def __init__(self):
+        pass
+
+    def catmull_rom_spline(self, p0, p1, p2, p3, t):  
+        # p0...p3: (..., 7)
+        # t: [num_samples, 1]
+        # Returns: [num_samples, 7]
+        # TODO: batch fit & samples
+        a = 2*p1
+        b = -p0 + p2
+        c = 2*p0 - 5*p1 + 4*p2 - p3
+        d = -p0 + 3*p1 - 3*p2 + p3
+        return 0.5 * (a + b * t + c * t**2 + d * t**3)
+
+class GuideManager(nn.Module, abc.ABC):
+    def __init__(self,
+                 dataset,
+                 tensor_args,
+                 clip_grad=False, clip_grad_rule='norm',
+                 max_grad_norm=1.0, max_grad_value=1.0,
+                 guidance_weight=0.1,
+                 ):
+        super().__init__()
+        self.dataset = dataset
+        self.clip_grad = clip_grad
+        self.clip_grad_rule = clip_grad_rule
+        self.max_grad_norm = max_grad_norm
+        self.max_grad_value = max_grad_value
+        self.device = tensor_args['device']
+        self.dtype = tensor_args['dtype']
+        self.guidance_weight = guidance_weight
+
+    def forward(self, x_normalized):
+        grad = torch.full_like(x_normalized, fill_value=0.0)
+        return grad
+
+    def update_observation(self, obs):
+        pass
+
+    def clip_gradient(self, grad):
+        if self.clip_grad:
+            if self.clip_grad_rule == 'norm':
+                return self.clip_grad_by_norm(grad)
+            elif self.clip_grad_rule == 'value':
+                return self.clip_grad_by_value(grad)
+            else:
+                raise NotImplementedError
+        else:
+            return grad
+
+    def clip_grad_by_norm(self, grad):
+        # clip gradient by norm
+        if self.clip_grad:
+            grad_norm = torch.linalg.norm(grad + 1e-6, dim=-1, keepdims=True)
+            scale_ratio = torch.clip(grad_norm, 0., self.max_grad_norm) / grad_norm
+            grad = scale_ratio * grad
+        return grad
+
+    def clip_grad_by_value(self, grad):
+        # clip gradient by value
+        if self.clip_grad:
+            grad = torch.clip(grad, -self.max_grad_value, self.max_grad_value)
+        return grad
+    
+    def reset(self):
+        pass
+    
+def running_avg(tensor, window_size):
+    """
+    Computes running average using PyTorch's conv1d operation.
+    
+    :param tensor: Input tensor of shape [batch_size, seq_len, dim]
+    :param window_size: Size of the sliding window
+    :return: Tensor with same shape as input, containing running averages
+    """
+    # PyTorch doesn't have a direct convolve function like numpy
+    # Need to handle batch dimensions properly for trajectory data
+    batch_size, seq_len, dim = tensor.shape
+    result = torch.zeros_like(tensor)
+    # Create the kernel for the running average
+    kernel = torch.ones(window_size, device=tensor.device) / window_size
+    # Apply running average to each dimension separately
+    for b in range(batch_size):
+        for d in range(dim):
+            # Use 1D convolution for running average
+            # F.conv1d expects input shape [batch, channels, length]
+            padded = torch.nn.functional.pad(tensor[b, :, d].unsqueeze(0).unsqueeze(0), 
+                                            (window_size-1, 0), mode='reflect')
+            convolved = torch.nn.functional.conv1d(padded, 
+                                                  kernel.view(1, 1, -1))
+            result[b, :, d] = convolved.squeeze()
+    return result
+
+class GuideManagerPath(GuideManager):
+    def __init__(self,
+                 dataset,
+                 tensor_args,
+                 clip_grad=False, clip_grad_rule='norm',
+                 max_grad_norm=1.0, max_grad_value=1.0,
+                 guidance_weight=0.15,
+                 ):
+        super().__init__(dataset, 
+                         tensor_args,
+                         clip_grad, clip_grad_rule, 
+                         max_grad_norm, max_grad_value,
+                         guidance_weight)
+        self._point_cloud = None
+        self._sdf_model = PointCloud_CSDF(sphere_radius=0.10, max_distance=0.04, device=self.device, pcd=None)
+        # print("GUIDANCE STRENGTH: ", self.guidance_weight)
+
+    def forward(self, x_normalized): 
+        #calculate sdf guidance
+        x_norm = x_normalized.clone()
+        with torch.enable_grad():
+            x_norm.requires_grad_(True)
+            x = self.dataset.unnormalize_trajectory(x_norm)
+            # calculate sdf guidance according to x and environment
+            sdf_guidance = self._calculate_sdf_guidance(x)
+            # print("sdf_guidance: ", sdf_guidance)
+            smooth_guidance = self._calculate_smooth_guidance(x)
+        # print("sdf_guidance: ", sdf_guidance)
+        # guidance = 0.1*sdf_guidance + 0.01*smooth_guidance
+        guidance = 0.1*sdf_guidance
+        # guidance = self.clip_gradient(guidance)
+        return self.guidance_weight*guidance
+
+    # Update observation for calculation this guidance
+    # This function is required to be called before forward()
+    def update_observation(self, obs):
+        self._point_cloud = obs['point_cloud']
+        self._sdf_model.update_pcd(self._point_cloud)
+    
+    def _calculate_sdf_guidance(self, x_unnormalized):
+        # Extract position coordinates (first 3 dimensions) and detach to handle gradients manually
+        positions = x_unnormalized[..., :3].detach().requires_grad_(True)
+        sdf_values = self._sdf_model(positions)  # [batch, length]
+        # print("positions shape:", positions.shape)
+        # print(f'SDF values: {sdf_values.cpu().detach().numpy()}')
+        # Calculate gradients through backward pass
+        sdf_values.sum().backward()
+        sdf_gradient = positions.grad  # Get gradient from positions tensor instead
+        sdf_gradient[:, 0] = 0.0
+        sdf_gradient[:, -1] = 0.0
+        running_avg_sdf_gradient = running_avg(sdf_gradient, 3)
+        # print(f'SDF gradient: {sdf_gradient.cpu().detach().numpy()}')
+        # Initialize guidance with zeros for all dimensions and apply SDF gradients to position dimensions
+        guidance = torch.zeros_like(x_unnormalized)
+        guidance[..., :3] = running_avg_sdf_gradient  # Use positions.grad instead of sdf_values.grad
+        
+        return guidance
+
+    def _calculate_smooth_guidance(self, x_unnormalized):
+        # Extract position coordinates and create a copy that requires gradients
+        positions = x_unnormalized[..., :3].detach().clone().requires_grad_(True)
+        
+        # Calculate the smoothness objective: sum of squared accelerations
+        if positions.shape[1] >= 3:
+            velocities = positions[:, 1:] - positions[:, :-1]
+            accelerations = velocities[:, 1:] - velocities[:, :-1]
+            smoothness_objective = torch.sum(torch.norm(accelerations, dim=-1)**2)
+            # Calculate gradients through automatic differentiation
+            smoothness_objective.backward()
+            # Get the gradient
+            smooth_grad = positions.grad
+            # Initialize guidance with zeros for all dimensions
+            guidance = torch.zeros_like(x_unnormalized)
+            guidance[..., :3] = -smooth_grad  # Negative to minimize the objective
+            
+            return guidance
+        else:
+            return torch.zeros_like(x_unnormalized)
+            
+
+class GuideManagerSTOMP(GuideManager):
+    class LocalDirectionMode(Enum):
+            WAYPOINT = 0
+            RESAMPLE_WAYPOINT = 1
+            RESAMPLE_SPLINE = 2
+
+    def __init__(self,
+                 dataset,
+                 robot_model,
+                 tensor_args,
+                 clip_grad=False, clip_grad_rule='norm',
+                 max_grad_norm=1.0, max_grad_value=1.0,
+                 guidance_weight=0.15
+                 ):
+        super().__init__(dataset,
+                         tensor_args,
+                         clip_grad, clip_grad_rule, 
+                         max_grad_norm, max_grad_value,
+                         guidance_weight)
+        mode_int = 1
+        self._local_direction_mode = self.LocalDirectionMode(mode_int)
+
+        self._point_cloud = None
+        self._max_distance = 0.20
+        self._sdf_model = PointCloud_CSDF(sphere_radius=0.05, max_distance=None, device=self.device, pcd=None)
+        # print("GUIDANCE STRENGTH: ", self.guidance_weight)
+        self._advanced_kinematics_solver = AdvancedKinematicsSolver(robot_model)
+        # self._selected_links = ["panda_link0", "panda_link1", "panda_link2", "panda_link3", 
+                        #    "panda_link4", "panda_link5", "panda_link6", "panda_link7", "panda_link8", "panda_hand"]
+        # self._selected_links = ["panda_link1", "panda_link2", "panda_link3", "panda_link4", 
+        #                         "panda_link5", "panda_link6", "panda_link7", "panda_link8", "panda_hand"]
+        self._selected_links = ["panda_link5", "panda_link6", "panda_link7", "panda_link8", "panda_hand", "panda_leftfinger", "panda_rightfinger"]
+        # Dictionary to store debug values that can be accessed from outside
+        self.debug_state = []
+    
+    def reset_debug_state(self):
+        self.debug_state = []
+    
+    def forward(self, x_normalized, get_cost_rank=False, get_debug_info=True):
+        x_norm = x_normalized.clone() # ⚠️ IMPORTANT: x should be joint states, not end-effector poses
+        x = self.dataset.unnormalize_trajectory(x_norm)  # x shape: [batch, length, joint_dim], joint_dim = 9
+        restructured_data = self._get_cartesian_positions(x)
+        sdf_cost = self._calculate_sdf_cost(restructured_data['all_sphere_poses'], restructured_data['all_sphere_radii'])  # [batch, seq_len, sphere_num]
+        # filter out the cost of the sphere that is not in the selected links
+        sdf_cost = self._filter_cost_by_mask(sdf_cost, restructured_data['all_sphere_mask']) # [batch, seq_len, sphere_num]
+        sdf_gradient = self._calculate_mixed_gradient(sdf_cost, x, alpha_global=3.0, sliding_window = 3, max_window_nums=5)
+        guidance = self.guidance_weight*sdf_gradient #delta value does not need normalized. delta and absolute does not share same normalizer
+        x_after_guidance = x + guidance
+        guidance_norm = self.dataset.normalizer.normalize(x_after_guidance, self.dataset.data_key_traj) - x_norm
+        
+        # ------ Debug info ------
+        if get_cost_rank:
+            # Sort batch indices by total cost (sum over all timesteps and spheres)
+            cost_total = sdf_cost.sum(dim=(1, 2))  # [batch]
+            self.sdf_cost_sorted_indices = torch.argsort(cost_total, dim=0)  # ascending order
+
+        if get_debug_info:
+            # Make sure to not modify x; use a copy for x_after_guidance
+            x_after_guidance = x.detach().cpu().numpy().copy() + guidance.detach().cpu().numpy().copy()
+            temp_data =self._get_cartesian_positions(x_after_guidance)
+            debug_entry = DebugEntry(
+                sphere_poses=restructured_data['all_sphere_poses'],
+                sphere_radii=restructured_data['all_sphere_radii'],
+                sdf_costs=sdf_cost,
+                spheres_after_guidance=temp_data['all_sphere_poses'], 
+                sampled_spheres=self.debug_local_samples_spheres,
+            )
+
+            self.debug_state.append(debug_entry)
+            # print("sdf_gradient shape: ", sdf_gradient.shape)
+            # print("SDF gradient statistics:")
+            # print(f"Shape: {sdf_gradient.shape}")
+            # print(f"Mean: {sdf_gradient.mean().item():.4f}")
+            # print(f"Std: {sdf_gradient.std().item():.4f}")
+            # print(f"Min: {sdf_gradient.min().item():.4f}")
+            # print(f"Max: {sdf_gradient.max().item():.4f}")
+            # print(f"Non-zero elements: {(sdf_gradient != 0).sum().item()}")
+        #---- end debug info ------
+        return guidance_norm 
+
+    def update_observation(self, obs):
+        self._point_cloud = obs['point_cloud']
+        self._sdf_model.update_pcd(self._point_cloud)
+    
+    def _get_cartesian_positions(self, joint_states): 
+        # what is the best way to get end-effector poses? shall I wrap the restructure function in this?
+        if isinstance(joint_states, torch.Tensor): # this is not efficient, but let's keep it for now for MVP
+            joint_states = joint_states.detach().cpu().numpy()
+        sphere_poses_list = []
+        sphere_radii_list = []
+        for b in range(joint_states.shape[0]):
+            batch_sphere_poses = []
+            batch_sphere_radii = []
+            for t in range(joint_states.shape[1]):
+                sphere_poses, sphere_radii = self._advanced_kinematics_solver.calculate_all_sphere_positions_and_radii(joint_states[b, t, :])
+                batch_sphere_poses.append(sphere_poses)
+                batch_sphere_radii.append(sphere_radii)
+            sphere_poses_list.append(batch_sphere_poses)
+            sphere_radii_list.append(batch_sphere_radii)
+                
+        restructured_data = self._restructure_sphere_data(sphere_poses_list, sphere_radii_list)
+        return restructured_data
+
+    def _filter_cost_by_mask(self, cost, sphere_mask):
+        filtered_cost = cost * sphere_mask
+        return filtered_cost
+
+    def _calculate_local_direction_from_resample_spline(self, 
+                                                        joint_states: torch.Tensor, 
+                                                        window_indices: torch.Tensor,
+                                                        alpha_local: float = 3.0):
+        """
+        Calculate the local direction for each timestep using a spline.
+        window_indices: [k, window_size]
+        joint_states: [batch, seq_len, joint_dim]
+        """
+        def batch_window_perturb_sample_spline(joint_states, window_indices, num_samples=8, perturb_std=0.1, num_interp=10):
+            """
+            For each [batch, window], perturb p2 of window and sample points on Catmull-Rom spline.
+            Args:
+                joint_states: [batch, seq_len, joint_dim]
+                window_indices: [num_windows, window_size]
+                num_samples: int, number of p2 perturbations per window
+                perturb_std: float, std of the perturbation
+                num_interp: int, number of sampled points per spline
+            Returns:
+                sampled_points: [batch, num_windows, num_samples, num_interp, joint_dim]
+                perturbed_controls: [batch, num_windows, num_samples, 4, joint_dim]
+            """
+            batch_size, seq_len, joint_dim = joint_states.shape
+            num_windows, window_size = window_indices.shape
+            
+            # Gather window control points: [batch, num_windows, window_size, joint_dim]
+            idx = einops.repeat(window_indices, 'w s -> b w s d', b=batch_size, d=joint_dim)
+            # Use gather to select each joint dim independently
+            joint_states_exp = einops.repeat(joint_states, 'b t d -> b w t d', w=num_windows)
+            window_points = torch.gather(joint_states_exp, 2, idx) # [batch, num_windows, window_size, joint_dim]
+            # print("window_points shape:", window_points.shape)
+
+            # Expand for batch p2 perturb: [batch, num_windows, num_samples, window_size, joint_dim]
+            controls = einops.repeat(window_points, 'b w t d -> b w n t d', n=num_samples)
+            noise = torch.randn(batch_size, num_windows, num_samples, joint_dim, device=joint_states.device) * perturb_std
+            # print("controls shape:", controls.shape)
+            # print("noise shape:", noise.shape)
+            controls = controls.clone() # [batch, num_windows, num_samples, window_size, joint_dim]
+            controls[:, :, :, 2, :] += noise  # Only perturb p2
+
+            # Interpolation
+            t = torch.linspace(0, 1, num_interp, device=joint_states.device)
+            t = einops.rearrange(t, 'i -> 1 1 1 i 1')  # [1, 1, 1, num_interp, 1]
+
+            # Controls: [batch, num_windows, num_samples, window_size, joint_dim]
+            p0 = einops.rearrange(controls[:, :, :, 0, :], 'b w n d -> b w n 1 d')
+            p1 = einops.rearrange(controls[:, :, :, 1, :], 'b w n d -> b w n 1 d')
+            p2 = einops.rearrange(controls[:, :, :, 2, :], 'b w n d -> b w n 1 d')
+            p3 = einops.rearrange(controls[:, :, :, 3, :], 'b w n d -> b w n 1 d')
+
+            a = 2 * p1
+            b = -p0 + p2
+            c = 2*p0 - 5*p1 + 4*p2 - p3
+            d = -p0 + 3*p1 - 3*p2 + p3
+
+            sampled_points = 0.5 * (a + b * t + c * t**2 + d * t**3)  # [batch, num_windows, num_samples, num_interp, joint_dim]
+
+            return sampled_points, controls, window_points
+        
+        def compute_sampled_gradient(sampled_points, cost, window_joint_states, alpha=4.0):
+            """
+            Args:
+                sampled_points: [batch, num_windows, num_samples, num_interp, joint_dim]
+                cost: [batch, w, n, t]
+                window_joint_states: [batch, window_num, window_size, joint_dim]
+                alpha: softmin temp
+            Returns:
+                grad: [batch, w, t, joint_dim]
+            """
+            # delta: each sample's difference to the current window's mean
+            # sampled_points: [batch, w, n, t, joint_dim]
+            # mean_joint_states_window: [batch, w, t, joint_dim] -> expand to match n
+            batch, joint_dim = sampled_points.shape[0], sampled_points.shape[-1]
+            n = sampled_points.shape[2]
+            num_windows = window_joint_states.shape[1]
+            t = sampled_points.shape[3]
+            delta = torch.zeros(batch, num_windows, n, t, joint_dim, device=sampled_points.device)
+            delta[..., 1, :] = sampled_points[..., 0, :] - window_joint_states[..., 1, :].unsqueeze(2).expand(-1, -1, n, -1)
+            delta[..., 2, :] = sampled_points[..., -1, :] - window_joint_states[..., 2, :].unsqueeze(2).expand(-1, -1, n, -1)
+            
+            # cost softmin over n (perturbations)
+            # cost: [batch, w, n, t]
+            cost_norm = cost - cost.amin(dim=2, keepdim=True)        # min-norm over n
+            weights = torch.softmax(-alpha * cost_norm, dim=2)       # [batch, w, n, t]
+            weights = weights.unsqueeze(-1)                          # [batch, w, n, t, 1]
+            grad = (weights * delta).sum(dim=2)                      # [batch, w, t, joint_dim]
+            return grad
+        
+        # mean_joint_states = joint_states.mean(dim=0).unsqueeze(0)  # [1, seq_len, joint_dim]
+        pertube_sample_num = 5
+        num_interp = window_indices.shape[1] # don't make it too complex..
+        # sampled_points, controls, window_points = batch_window_perturb_sample_spline(
+        #     mean_joint_states, 
+        #     window_indices, 
+        #     num_samples=pertube_sample_num, 
+        #     num_interp=num_interp
+        # )
+        sampled_points, controls, window_points = batch_window_perturb_sample_spline(
+            joint_states, 
+            window_indices, 
+            num_samples=pertube_sample_num, 
+            num_interp=num_interp,
+            perturb_std=0.2
+        )
+        # print("window_points shape:", window_points.shape)
+        # print("sampled_points shape:", sampled_points.shape)
+        # print("controls shape:", controls.shape)
+        sampled_points = einops.rearrange(sampled_points, 'b w n t d -> b (w n t) d')
+        restructured_data = self._get_cartesian_positions(sampled_points)
+        sdf_cost = self._calculate_sdf_cost(restructured_data['all_sphere_poses'], restructured_data['all_sphere_radii'])
+        # filter out the cost of the sphere that is not in the selected links
+        sdf_cost = self._filter_cost_by_mask(sdf_cost, restructured_data['all_sphere_mask']).sum(dim=-1) #[batch, seq_len]
+        cost = einops.rearrange(sdf_cost, 'b (w n t) -> b w n t', w=window_indices.shape[0], n = pertube_sample_num, t = num_interp)
+        sampled_points = einops.rearrange(sampled_points, 'b (w n t) d -> b w n t d', w=window_indices.shape[0], n = pertube_sample_num, t = num_interp)
+        
+        # print("cost shape:", cost.shape)
+        # softmax gradient over the cost
+        grad = compute_sampled_gradient(sampled_points, cost, window_points, alpha=1.0)
+        # print("grad shape:", grad.shape)
+        # print("grad:", grad[0,0,:])
+
+        # transform gard to original joint index
+        # grad: [batch, num_windows, num_interp, joint_dim]
+        # window_indices: [num_windows, num_interp]
+        batch, num_windows, num_interp, joint_dim = grad.shape
+        seq_len = joint_states.shape[1]
+
+        # Expand window_indices for batch和joint_dim
+        grad_flat = einops.rearrange(grad, 'b w t d -> b (w t) d')
+        # print("grad_flat shape:", grad_flat.shape)
+        # print("grad flat value:", grad_flat)
+        idx_flat = einops.rearrange(window_indices, 'w t -> (w t)')
+        idx_flat = einops.repeat(idx_flat, 'n -> b n d', b=batch, d=joint_dim)
+        
+        grad_full = torch.zeros(batch, seq_len, joint_dim, device=grad.device)
+        grad_full = grad_full.scatter_add(dim=1, index=idx_flat, src=grad_flat)
+
+        return grad_full
+    
+    def _calculate_local_direction_from_resample_waypoint(self,
+                                                          joint_states: torch.Tensor, 
+                                                          window_indices: torch.Tensor,
+                                                          alpha_local: float = 3.0,
+                                                          perturb_std: float = 0.2):
+        """Calculate the local direction for each timestep using a waypoint."""
+        def batch_perturb_and_resample(joint_states, window_indices, perturb_plan, perturb_std=0.2, num_interp=10):
+            # sample from polygon, not gaussian
+            batch_size, seq_len, joint_dim = joint_states.shape
+            num_windows, window_size = window_indices.shape
+            # assert window_size == 4
+            num_samples = len(perturb_plan)
+            
+            # Gather window control points: [batch, num_windows, window_size, joint_dim]
+            idx = einops.repeat(window_indices, 'w s -> b w s d', b=batch_size, d=joint_dim)
+            # Use gather to select each joint dim independently
+            joint_states_exp = einops.repeat(joint_states, 'b t d -> b w t d', w=num_windows)
+            window_points = torch.gather(joint_states_exp, 2, idx) # [batch, num_windows, window_size, joint_dim]
+            # print("window_points shape:", window_points.shape)
+
+            # Joint sampling, batch expansion and perturbation: [batch, num_windows, num_samples, window_size, joint_dim]
+            # perturbed_windows = einops.repeat(window_points, 'b w t d -> b w n t d', n=num_samples)
+            ## noise = torch.randn(batch_size, num_windows, num_samples, window_size, joint_dim, device=joint_states.device) * perturb_std
+            ## perturbed_windows = perturbed_windows + noise  # [batch, num_windows, num_samples, window_size, joint_dim]
+            # perturbed_windows = trust_region_perturbations(window_points, perturb_std, perturb_plan)
+
+            # Cartesian sampling
+            perturbed_windows = trust_region_cartesian_perturbations(window_points, perturb_std, perturb_plan)
+
+            # Resampling/interpolation:
+            # Reshape to (batch * num_windows * num_samples, window_size, joint_dim) for efficient interpolation
+            flat = perturbed_windows.reshape(-1, window_size, joint_dim)  # [BWN, window_size, joint_dim]
+            flat_up = F.interpolate(flat.transpose(1, 2), size=num_interp, mode='linear', align_corners=True)
+            flat_up = flat_up.transpose(1, 2)  # [BWN, num_interp, joint_dim]
+            resampled = flat_up.view(batch_size, num_windows, num_samples, num_interp, joint_dim)
+            return resampled, perturbed_windows, window_points  # [batch, num_windows, num_samples, num_interp, joint_dim], [batch, num_windows, num_samples, window_size, joint_dim]
+
+        def trust_region_perturbations(window_points, std, perturb_plan):
+            num_samples = len(perturb_plan)
+            batch, num_windows, window_size, joint_dim = window_points.shape
+            perturbed = window_points.unsqueeze(2).expand(-1, -1, num_samples, -1, -1).clone()
+
+            for sample_idx, plan in enumerate(perturb_plan):
+                for idx in range(1, window_size-1):  # skip first and last
+                    for joint_id, sign in plan:
+                        perturbed[:, :, sample_idx, idx, joint_id] += sign * std
+            return perturbed
+
+
+        def trust_region_cartesian_perturbations(window_points, std, cartesian_perturb_dirs):
+            """
+            window_points: [batch, num_windows, window_size, joint_dim]
+            num_samples: int
+            std: float
+            return: [batch, num_windows, num_samples, window_size, joint_dim]
+            """
+            dirs = np.array([
+                    [1, 1, 1], [1, 1, -1], [1, -1, 1], [1, -1, -1],
+                    [-1, 1, 1], [-1, 1, -1], [-1, -1, 1], [-1, -1, -1]
+                ], dtype=np.float32)
+            
+            num_dirs = dirs.shape[0]
+            b, w, t, d = window_points.shape
+
+            # Move to CPU/numpy for IK and FK
+            window_points_np = window_points.detach().cpu().numpy().reshape(-1, d)  # (N, d)
+            perturbed_qpos_list = []
+
+            for qpos in window_points_np:
+                self._advanced_kinematics_solver.calculate_forward_kinematics(qpos)
+                cartesian_pose = self._advanced_kinematics_solver.get_all_link_pose()["panda_hand"]
+                # Perturb in cartesian space
+                perturbed_cartesian_poses = perturb_cartesian_pose(cartesian_pose, std, dirs=dirs)  # (num_dirs, 7)
+                # IK for each perturbed pose
+                perturbed_qpos = []
+                for pose in perturbed_cartesian_poses:
+                    qpos_ik = self._advanced_kinematics_solver.compute_ik(pose, initial_qpos=qpos)
+                    if qpos_ik is None:
+                        qpos_ik = qpos  # fallback
+                    perturbed_qpos.append(qpos_ik)
+                perturbed_qpos = np.stack(perturbed_qpos, axis=0)  # (num_dirs, d)
+                perturbed_qpos_list.append(perturbed_qpos)
+        
+            # Stack and reshape
+            perturbed_windows = np.stack(perturbed_qpos_list, axis=0)  # (b * w * t, num_dirs, d)
+            perturbed_windows = perturbed_windows.reshape(b, w, t, num_dirs, d)
+            perturbed_windows = np.transpose(perturbed_windows, (0, 1, 3, 2, 4))  # → [b, w, num_dirs, t, d]
+            perturbed_windows = torch.tensor(perturbed_windows, device=window_points.device, dtype=window_points.dtype)
+            return perturbed_windows
+        
+        def perturb_cartesian_pose(cartesian_pose, edge_len, dirs = None):
+            """
+            Generate 8 perturbed poses that form a cube around the input pose.
+            Args:
+                cartesian_pose: Pose object or np.ndarray with fields .p (position [3]) and .q (quaternion [4])
+                edge_len: float, total edge length of the cube
+            
+            Returns:
+                perturbed_poses: [batch, num_dirs, 7]  # 7 for (x, y, z, qw, qx, qy, qz)
+            """
+            if dirs is None:
+                dirs = np.array([
+                    [1, 1, 1], [1, 1, -1], [1, -1, 1], [1, -1, -1],
+                    [-1, 1, 1], [-1, 1, -1], [-1, -1, 1], [-1, -1, -1]
+                ], dtype=np.float32)
+            
+            dirs = dirs / np.linalg.norm(dirs, axis=1, keepdims=True)  # normalize
+            half_diag = edge_len / 2.0
+            displacements = dirs * half_diag  # length from center to each corner
+
+            pos = cartesian_pose.p  # [3]
+            quat = cartesian_pose.q  # [4]
+
+            pos_perturbed = pos[None, :] + displacements  # [8, 3]
+            # Add small random perturbations to quaternions
+            quat_noise = np.random.normal(0, 0.15, (8, 4))  # Small Gaussian noise
+            quat_perturbed = quat[None, :] + quat_noise  # [8, 4]
+            # Normalize quaternions to ensure they remain valid
+            quat_norms = np.linalg.norm(quat_perturbed, axis=1, keepdims=True)
+            quat_perturbed = quat_perturbed / quat_norms
+
+            perturbed_poses = np.concatenate([pos_perturbed, quat_perturbed], axis=-1)  # [8, 7]
+            return perturbed_poses
+
+        def compute_sampled_gradient(sampled_points, cost, window_joint_states, alpha=4.0):
+            cost_per_sample = cost.sum(dim=-1) # [batch, num_windows, num_samples]
+            # 2. Softmin over samples (n) in each window
+            # cost_norm = cost_per_sample - cost_per_sample.amin(dim=2, keepdim=True)
+            cost_norm = (cost_per_sample - cost_per_sample.mean(dim=2, keepdim=True)) / (cost_per_sample.std(dim=2, keepdim=True) + 1e-8)
+            weights = torch.softmax(-alpha * cost_norm, dim=2)  # [batch, num_windows, num_samples]
+            
+            # cost_per_sample shape: torch.Size([batch, num_windows, pertube_nums])
+            # resampled_sampled_points shape: torch.Size([batch, num_windows, pertube_nums, window_length , 9])
+            # window_joint_states shape: torch.Size([batch, num_windows, window_length , 9])
+            delta = sampled_points - window_joint_states.unsqueeze(2)  # [batch, num_windows, num_samples, window_length, joint_dim]
+            # print("cost norm", cost_norm)
+            # print("weights", weights)
+            # print("delta shape", delta.shape)
+            # print("delta[0,0,0,:]", delta[0,0,0,:])
+            # print("delta[0,0,1,:]", delta[0,0,1,:])
+            # grad_window = delta[:,:,0,:,:]
+            weights_expand = weights.unsqueeze(-1).unsqueeze(-1)  # [batch, num_windows, num_samples, 1, 1]
+            grad_window = (weights_expand * delta).sum(dim=2)  # [batch, num_windows, window_length, joint_dim]
+            return grad_window
+            
+        def reinterpolate_sampled_points(sampled_points, window_indices, num_interp=10):
+            # sampled_points: [batch, num_windows, num_samples, num_interp, joint_dim]
+            # window_indices: [num_windows, num_interp]
+            # sampled_points: [b, w, n, num_interp, d]
+            b, w, n, num_interp, d = sampled_points.shape
+            target_t = window_indices.shape[1]
+            # Reshape for interpolation: [b*w*n, d, num_interp]
+            sampled_points_reshaped = sampled_points.permute(0, 1, 2, 4, 3).reshape(-1, d, num_interp)
+            # Interpolate along t dimension
+            sampled_points_interp = F.interpolate(
+                sampled_points_reshaped, 
+                size=target_t, 
+                mode='linear', 
+                align_corners=True
+            )
+            # Reshape back: [b, w, n, d, target_t]
+            sampled_points_interp = sampled_points_interp.reshape(b, w, n, d, target_t).permute(0, 1, 2, 4, 3)
+            return sampled_points_interp
+
+        # def resample_to_original_window_size(sampled_points, window_points, window_indices):
+        # 
+        
+        # perturb_plan = [
+        #     [(3, +2), (6, -3)],  # joint3 +2, joint6 -2
+        #     [(3, -2), (5, -3)],  # joint3 -2, joint5 -2
+        #     [(0, +1), (3, +2)],  # joint0 +1, joint3 +2
+        #     [(0, -1), (4, +3)],  # joint0 -1, joint4 +2
+        #     [(1, +1), (3, -2)],  # joint1 +1, joint3 -2
+        #     [(1, -1), (5, +3)],  # joint1 -1, joint5 +2
+        #     [(2, +1), (4, -3)],  # joint2 +1, joint4 -2
+        #     [(2, -1), (6, +3)],  # joint2 -1, joint6 +2
+        # ]
+
+        # perturb_plan = [ #joint
+        #     [(0, +0.5)], [(0, -0.5)], [(1, +1.0)], [(1, -1.0)], [(2, +1.0)], [(2, -1.0)],
+        #     [(3, +2.0)], [(3, -2.0)], [(4, +3.0)], [(4, -3.0)], 
+        #     [(5, +4.0)], [(5, -4.0)], [(6, +4.0)], [(6, -4.0)],
+        # ]
+        num_interp = 4 # don't make it too complex..
+
+        perturb_plan = np.array([ #cartesian
+                    [1, 1, 1], [1, 1, -1], [1, -1, 1], [1, -1, -1],
+                    [-1, 1, 1], [-1, 1, -1], [-1, -1, 1], [-1, -1, -1]
+                ], dtype=np.float32)
+    
+        sampled_points, perturbed_windows, window_points = batch_perturb_and_resample(
+            joint_states, 
+            window_indices, 
+            perturb_plan,
+            num_interp=num_interp,
+            perturb_std=perturb_std
+        )
+        num_samples = len(perturb_plan)
+        # print("perturbed_windows shape:", perturbed_windows.shape)
+        # print("sampled_points shape:", sampled_points.shape)
+        sampled_points = einops.rearrange(sampled_points, 'b w n t d -> b (w n t) d') # [batch, (w pertube_sample_num, num_interp), joint_dim]
+        restructured_data = self._get_cartesian_positions(sampled_points)
+        sdf_cost = self._calculate_sdf_cost(restructured_data['all_sphere_poses'], restructured_data['all_sphere_radii'])
+        # filter out the cost of the sphere that is not in the selected links
+        sdf_cost = self._filter_cost_by_mask(sdf_cost, restructured_data['all_sphere_mask']).sum(dim=-1) #[batch, seq_len]
+        
+        cost = einops.rearrange(sdf_cost, 'b (w n t) -> b w n t', w=window_indices.shape[0], n = num_samples, t = num_interp)
+        # print("cost", cost)
+        sampled_points = einops.rearrange(sampled_points, 'b (w n t) d -> b w n t d', w=window_indices.shape[0], n = num_samples, t = num_interp) #this need to be resampled to ori
+        resampled_sampled_points = reinterpolate_sampled_points(sampled_points, window_indices, num_interp=num_interp)
+        # # print("resampled_sampled_points shape:", resampled_sampled_points.shape)
+        grad = compute_sampled_gradient(resampled_sampled_points, cost, window_points, alpha=8.0)
+        # grad = compute_sampled_gradient(sampled_points, cost, window_points, alpha=4.0)
+        # grad = sampled_points[:,:,0,:,:] - window_points
+
+        # print("local grad shape:", grad.shape)
+        # print("local grad value:", grad.sum(dim=3))
+        self.debug_local_samples_spheres = restructured_data['all_sphere_poses']
+        # transform gard to original joint index
+        # grad: [batch, num_windows, num_interp, joint_dim]
+        # window_indices: [num_windows, num_interp]
+        batch, num_windows, num_interp, joint_dim = grad.shape
+        seq_len = joint_states.shape[1]
+
+        # # Expand window_indices for batch and joint_dim
+        grad_flat = einops.rearrange(grad, 'b w t d -> b (w t) d')
+        # print("grad_flat shape:", grad_flat.shape)
+        idx_flat = einops.rearrange(window_indices, 'w t -> (w t)')
+        idx_flat = einops.repeat(idx_flat, 'n -> b n d', b=batch, d=joint_dim)
+        
+        grad_full = torch.zeros(batch, seq_len, joint_dim, device=grad.device)
+        grad_full = grad_full.scatter_add(dim=1, index=idx_flat, src=grad_flat)
+        # Compute statistics along all except the last dimension (joint_dim)
+        # mean_per_joint = grad_full.mean(dim=(0,1))  # [joint_dim]
+        # std_per_joint  = grad_full.std(dim=(0,1))   # [joint_dim]
+        # min_per_joint  = grad_full.amin(dim=(0,1))  # [joint_dim]
+        # max_per_joint  = grad_full.amax(dim=(0,1))  # [joint_dim]
+
+        # print("Mean per joint:", mean_per_joint)
+        # print("Std per joint:", std_per_joint)
+        # print("Min per joint:", min_per_joint)
+        # print("Max per joint:", max_per_joint)
+        # print("grad_full shape:", grad_full.shape)
+                
+        return grad_full
+        
+        # print("cost shape:", cost.shape)
+        # raise NotImplementedError("Resample waypoint is not implemented yet")
+
+    def _calculate_local_direction_from_waypoint(self, cost: torch.Tensor, joint_states: torch.Tensor, alpha_local: float = 3.0):
+        """
+        Calculate the local direction for each timestep using a waypoint.
+        """
+        batch, seq_len = cost.shape
+        # 2. Calculate local direction for each timestep
+        local_direction_list = []
+        for t in range(seq_len):
+            # Get cost for all samples at this waypoint
+            cost_t = cost[:, t]  # [batch]
+            # Normalize: softmin, i.e. exp(-alpha_local * (cost_t - min))
+            cost_t_norm = cost_t - cost_t.min()
+            weights_local = torch.exp(-alpha_local * cost_t_norm)
+            weights_local = weights_local / (weights_local.sum() + 1e-8)  # [batch]
+            # States at current timestep
+            states_t = joint_states[:, t, :]  # [batch, joint_dim]
+            mean_state = states_t.mean(dim=0)
+            # Weighted direction relative to the mean state
+            direction = (weights_local[:, None] * (states_t - mean_state)).sum(dim=0)  # [joint_dim]
+            local_direction_list.append(direction)
+        local_direction = torch.stack(local_direction_list, dim=0)  # [seq_len, joint_dim]
+        return local_direction
+    
+    def _calculate_mixed_gradient(
+        self,
+        cost: torch.Tensor,
+        joint_states: torch.Tensor,
+        alpha_local: float = 3.0,
+        alpha_global: float = 3.0,
+        sliding_window: int = 4,
+        max_window_nums: int = 3,
+    ) -> torch.Tensor:
+        """
+        Combine full-trajectory and per-timestep weighted STOMP updates for a mixed gradient direction.
+        Args:
+            cost: [batch, seq_len, cost_per_sphere]    # tensor
+            joint_states: [batch, seq_len, joint_dim]  # tensor
+            alpha: float, softmax scaling factor
+            lambda_local: float, blending ratio for per-timestep (local) update
+        Returns:
+            grads: [seq_len, joint_dim]                # tensor
+        """
+        batch, seq_len, sphere_nums = cost.shape
+        device = cost.device
+
+        # ------ Compute GLOBAL weight for each waypoint using sliding window of costs ------
+        cost_per_sample = cost.sum(dim=-1)  # [batch, seq_len]
+        window_costs = self._sliding_window_sum(cost_per_sample, sliding_window) # TODO: assume no...multi modes (will fix)
+        
+        # Normalize using global mean
+        window_costs_norm =(window_costs - window_costs.min()) / (window_costs.max()+1e-8)
+        
+        # Compute softmax weights
+        softmax_weights = torch.exp(alpha_global * window_costs_norm)
+        global_weight = softmax_weights / (softmax_weights.sum() + 1e-8)
+        # print("window_costs_norm:", window_costs_norm)
+        # print("weights_t:", global_weight)
+        
+        # ------ Calculate local update direction ------
+        if self._local_direction_mode == self.LocalDirectionMode.RESAMPLE_SPLINE:
+            window_indices = self._get_window_indices(seq_len, sliding_window, device=device)
+            top_k_values, top_k_window_indices = self._get_top_k_windows(window_costs, window_indices, k=max_window_nums)
+            # print("top_k_values:", top_k_values)
+            # print("top_k_window_indices:", top_k_window_indices)
+            local_direction = self._calculate_local_direction_from_resample_spline(joint_states, 
+                                                                                   top_k_window_indices, 
+                                                                                   alpha_local)
+        elif self._local_direction_mode == self.LocalDirectionMode.RESAMPLE_WAYPOINT:
+            window_indices = self._get_window_indices(seq_len, sliding_window, device=device)
+            top_k_values, top_k_window_indices = self._top_k_windows_with_low_overlap(window_costs, window_indices, k=max_window_nums)
+            # print("top_k_values:", top_k_values)
+            # print("top_k_window_indices:", top_k_window_indices)
+            local_direction = self._calculate_local_direction_from_resample_waypoint(joint_states, 
+                                                                                   top_k_window_indices, 
+                                                                                   alpha_local,
+                                                                                   perturb_std=0.2)
+
+        elif self._local_direction_mode == self.LocalDirectionMode.WAYPOINT:
+            cost_per_sample = cost.sum(dim=-1)  # [batch, seq_len]
+            local_direction = self._calculate_local_direction_from_waypoint(cost_per_sample, joint_states, alpha_local)
+        else:
+            raise ValueError(f"Invalid local direction mode: {self._local_direction_mode}")
+
+        # ------ Combine local direction and global weight for each waypoint ------
+        # global_weight: [seq_len], local_direction: [seq_len, joint_dim]
+        grads = global_weight.unsqueeze(-1) * local_direction  # [seq_len, joint_dim]
+        # print("global_weight:", global_weight)
+        # grads = local_direction
+        
+        # Fix the start and end waypoints (do not update)
+        grads[:, 0, :] = 0.0
+        grads[:,-1, :] = 0.0
+
+        # print("grads.shape:", grads.shape)
+        # print("cost per sample:", cost_per_sample)
+        return grads
+    
+    def _sliding_window_sum(self, cost_per_sample, sliding_window_size):
+        # Add a channel dimension for conv1d: [batch, 1, seq_len]
+        cost = cost_per_sample.unsqueeze(1)
+        weight = torch.ones(1, 1, sliding_window_size, device=cost.device) #kernel[1,1,sliding_window]
+        # Pad both sides
+        if sliding_window_size % 2 == 1:  # odd
+            pad_left = pad_right = sliding_window_size // 2
+        else:  # even
+            pad_left = sliding_window_size // 2 - 1
+            pad_right = sliding_window_size // 2
+        cost_padded = F.pad(cost, (pad_left, pad_right), mode='constant', value=0)
+        window_sum = F.conv1d(cost_padded, weight) # output: [batch, 1, seq_len]
+        window_sum = window_sum.sum(dim=0).squeeze(0)  # sum across batch dimension[seq_len]
+        return window_sum
+    
+    def _get_window_indices(self, seq_len, window_size, fill_value=-1, device=None):
+        t = torch.arange(seq_len, device=device)  # [seq_len]
+        half = window_size // 2
+        offsets = torch.arange(-half, window_size - half, device=device).view(1, -1)
+        window_indices = t.view(-1, 1) + offsets
+        window_indices = torch.where(
+            (window_indices >= 0) & (window_indices < seq_len),
+            window_indices,
+            torch.full_like(window_indices, fill_value)
+        )
+        return window_indices  # [seq_len, window_size]
+    
+    def _smooth_grads(grads: torch.Tensor, weight: float = 0.4) -> torch.Tensor:
+        """
+        Apply a simple smoothing filter to the gradient updates by blending each waypoint with its immediate neighbors.
+        Args:
+            grads: torch.Tensor of shape [seq_len, joint_dim]
+                The gradient updates to be smoothed.
+            weight: float, optional (default=0.4)
+                Smoothing strength. 0 means no smoothing, higher values result in smoother gradients.
+        Returns:
+            grads_smooth: torch.Tensor of shape [seq_len, joint_dim]
+                The smoothed gradient updates.
+        """
+        grads_smooth = grads.clone()
+        # Smooth all inner waypoints by blending them with the ir left and right neighbors
+        grads_smooth[1:-1] = (
+            (1 - weight) * grads[1:-1]
+            + (weight / 2) * (grads[:-2] + grads[2:])
+        )
+        return grads_smooth
+            
+    def _calculate_sdf_cost(self, sphere_poses_tensor, sphere_radii_tensor):
+        assert sphere_poses_tensor.shape[:3] == sphere_radii_tensor.shape
+        batch_size, seq_len, num_spheres, _ = sphere_poses_tensor.shape
+        sphere_positions_flat = einops.rearrange(sphere_poses_tensor, 'b t s d -> b (t s) d')
+        sdf_distance_center = self._sdf_model(sphere_positions_flat)
+        sdf_distance_center = einops.rearrange(sdf_distance_center, 'b (t s) -> b t s', b=batch_size, t=seq_len)
+        # Distance from sphere surface
+        sdf_distance_surface = sdf_distance_center - sphere_radii_tensor
+
+        alpha = 8.0  
+        max_distance = self._max_distance  # should be scalar
+        clipped_distance = torch.clamp_max(sdf_distance_surface, max_distance)
+        sdf_cost = torch.exp(alpha * (max_distance - clipped_distance)) - 1
+        sdf_cost = torch.where(sdf_cost > 0, sdf_cost, torch.zeros_like(sdf_cost))
+        # print("sdf_cost mean:", sdf_cost.mean())
+        # print("sdf_cost max:", sdf_cost.max())
+        # print("sdf_cost min:", sdf_cost.min())
+
+        # # Clip at max_distance
+        # max_distance = self._max_distance  # should be scalar
+        # clipped_distance = torch.clamp_max(sdf_distance_surface, max_distance)
+        # sdf_cost = torch.clamp(max_distance - clipped_distance, min=0)
+        return sdf_cost
+
+    def _restructure_sphere_data(self, 
+                                 batch_sphere_poses_list: List[List[Dict[str, List[np.ndarray]]]], 
+                                 batch_sphere_radii_list: List[List[Dict[str, List[float]]]]):
+        batch_size = len(batch_sphere_poses_list)
+        seq_len = len(batch_sphere_poses_list[0])
+        spheres_per_link = {link: len(spheres) for link, spheres in batch_sphere_poses_list[0][0].items()}
+        total_spheres = sum(spheres_per_link.values())
+
+        def create_single_qpos_sphere(sphere_pose_list, sphere_radii_list):
+            sphere_poses = torch.zeros((seq_len, total_spheres, 3), device=self.device, dtype=self.dtype)
+            sphere_radii = torch.zeros((seq_len, total_spheres), device=self.device, dtype=self.dtype)
+            for t in range(seq_len):
+                idx = 0
+                for link_name, spheres in sphere_pose_list[t].items():
+                    n = len(spheres)
+                    if n == 0:
+                        continue
+                    radii = sphere_radii_list[t][link_name]
+                    assert n == len(radii), f"Mismatch: {n} spheres vs {len(radii)} radii for {link_name} at t={t}"
+                    sphere_poses[t, idx:idx+n] = torch.from_numpy(np.stack(spheres)).to(device=self.device, dtype=self.dtype)
+                    sphere_radii[t, idx:idx+n] = torch.tensor(radii, device=self.device, dtype=self.dtype)
+                    idx += n
+                assert idx == total_spheres, f"Total spheres mismatch at t={t}"
+            return sphere_poses, sphere_radii
+
+        def create_sphere_mask(sphere_pose_list):
+            mask = torch.zeros((seq_len, total_spheres), device=self.device, dtype=torch.bool)
+            for t in range(seq_len):
+                idx = 0
+                for link_name, spheres in sphere_pose_list[t].items():
+                    n = len(spheres)
+                    if n == 0:
+                        continue
+                    if hasattr(self, '_selected_links') and link_name in self._selected_links:
+                        mask[t, idx:idx+n] = True
+                    idx += n
+                assert idx == total_spheres, f"Total spheres mismatch at t={t}"
+            return mask
+
+        all_sphere_poses_tensor = torch.zeros((batch_size, seq_len, total_spheres, 3), device=self.device, dtype=self.dtype)
+        all_sphere_radii_tensor = torch.zeros((batch_size, seq_len, total_spheres), device=self.device, dtype=self.dtype)
+        # Create the mask only once, using the first batch's structure
+        mask = create_sphere_mask(batch_sphere_poses_list[0])
+        all_sphere_mask_tensor = mask.unsqueeze(0).expand(batch_size, -1, -1).clone()
+
+        for b in range(batch_size):
+            poses, radii = create_single_qpos_sphere(batch_sphere_poses_list[b], batch_sphere_radii_list[b])
+            all_sphere_poses_tensor[b] = poses
+            all_sphere_radii_tensor[b] = radii
+            # No need to recompute mask for each batch
+
+        return {
+            'all_sphere_poses': all_sphere_poses_tensor,
+            'all_sphere_radii': all_sphere_radii_tensor,
+            'all_sphere_mask': all_sphere_mask_tensor,
+        }
+
+    def _top_k_windows_with_low_overlap(self, window_costs: torch.Tensor, 
+                                   window_indices: torch.Tensor, 
+                                   k: int = 3):
+        """
+        Returns up to top k non-overlapping windows (no two windows share more than 1 index).
+        """
+        valid_mask = (window_indices >= 0).all(dim=1)
+        valid_costs = window_costs[valid_mask]
+        valid_indices = window_indices[valid_mask]  # [num_valid, window_size]
+
+        # Sort windows by cost descending (or ascending as you need)
+        sorted_costs, sorted_idx = torch.topk(valid_costs, min(len(valid_costs), k*4))  # oversample for filter
+        sorted_indices = valid_indices[sorted_idx]
+
+        selected = []
+        selected_indices = []
+
+        for idx, indices in enumerate(sorted_indices):
+            indices_set = set(indices.tolist())
+            # Check overlap with all previously selected
+            overlap = False
+            for prev in selected_indices:
+                prev_set = set(prev.tolist())
+                if len(indices_set & prev_set) > 1:
+                    overlap = True
+                    break
+            if not overlap:
+                selected.append(sorted_costs[idx])
+                selected_indices.append(indices)
+                if len(selected) == k:
+                    break
+
+        if selected:
+            return (torch.stack(selected), torch.stack(selected_indices))
+        else:
+            # No valid windows
+            return (
+                torch.empty(0, dtype=window_costs.dtype, device=window_costs.device),
+                torch.empty(0, window_indices.shape[1], dtype=window_indices.dtype, device=window_indices.device)
+            )
+
+    def _get_top_k_windows(self, window_costs: torch.Tensor, 
+                       window_indices: torch.Tensor, 
+                       k: int = 3):
+        """
+        Returns top k windows where all indices are in [0, seq_len).
+        Handles cases where invalid indices may be -1 or any other out-of-bounds value.
+        """
+        # valid_mask is True for windows where all indices are valid
+        valid_mask = (window_indices >= 0).all(dim=1)
+        # print("valid_mask:", valid_mask)
+        # print("window_indices.shape:", window_indices.shape)
+        # print("window_costs.shape:", window_costs.shape)
+        valid_costs = window_costs[valid_mask]
+        valid_indices = window_indices[valid_mask]
+
+        if valid_costs.numel() == 0:
+            return (
+                torch.empty(0, dtype=window_costs.dtype, device=window_costs.device),
+                torch.empty(0, *window_indices.shape[1:], dtype=window_indices.dtype, device=window_indices.device)
+            )
+        # Top-k over valid windows only
+        top_k = min(k, len(valid_costs))
+        top_k_values, top_k_idx = torch.topk(valid_costs, top_k)
+        top_k_window_indices = valid_indices[top_k_idx]
+        return top_k_values, top_k_window_indices
+
+    def reset(self):
+        self.reset_debug_state()
+
+class TrajectoryRanker():
+    def __init__(self,
+                 dataset,
+                 robot_model,
+                 get_current_qpos,
+                 tensor_args):
+        """ Initialize the TrajectoryRanker with dataset and tensor arguments."""
+        self.dataset = dataset
+        self.device = tensor_args['device']
+        self.dtype = tensor_args['dtype']
+        self._point_cloud = None
+        self._max_distance = 0.20
+        self._sdf_model = PointCloud_CSDF(sphere_radius=0.05, 
+                    max_distance=None, 
+                    device=self.device, 
+                    pcd=None)
+        self._kin_solver = AdvancedKinematicsSolver(robot_model)
+        self._get_current_qpos = get_current_qpos
+        # self._selected_links = ["panda_link0", "panda_link1", "panda_link2", "panda_link3", 
+        #                    "panda_link4", "panda_link5", "panda_link6", "panda_link7", 
+        #                    "panda_link8", "panda_hand", "panda_leftfinger", "panda_rightfinger"]
+        self._selected_links = ["panda_link5", "panda_link6", "panda_link7", "panda_link8", 
+                                "panda_hand", "panda_leftfinger", "panda_rightfinger"]
+
+        # Dictionary to store debug values that can be accessed from outside
+        self.debug_state = []
+    
+    def rank_trajectory(self, traj: torch.Tensor, traj_type: str = "joint"):
+        """
+        Unified entrypoint.
+        
+        Args:
+            traj: [B, T, D] normalized trajectory (D = 7 for EE, D = joint_dim for joint)
+            traj_type: "ee" or "joint"
+        Returns:
+            ranking_ids: [B]
+            ranked_traj: [B, T, D] (still in normalized space)
+        """
+        traj, joint_traj, valid_mask = self._prepare_trajectory_inputs(
+            traj,
+            traj_type
+        )
+
+        original_B = valid_mask.shape[0]
+        valid_B = traj.shape[0]  # after masking
+
+        if valid_B == 0:
+            raise RuntimeError("All trajectories invalid.")
+
+        ranking_ids, sdf_cost = self._rank_joint_trajectory_by_cost(joint_traj)
+        sorted_trajs = traj[ranking_ids]  # [valid_B, T, D]
+
+        # Repeat fill
+        repeat_factor = (original_B + valid_B - 1) // valid_B
+        tiled_trajs = sorted_trajs.repeat((repeat_factor, 1, 1))[:original_B]
+
+        return tiled_trajs
+
+        # ranking_ids, sdf_cost = self._rank_joint_trajectory_by_cost(joint_traj)
+        # print(f"Ranking IDs: {ranking_ids}")
+        # total_cost = sdf_cost.sum(dim=(1, 2))
+        # print(f"Total Cost: {total_cost[ranking_ids]}")
+        # return ranking_ids, traj[ranking_ids]  # return in normalized space
+    
+    def inpaint_trajectory(self, traj: torch.Tensor, traj_type: str = "joint", 
+                            num_windows: int = 4, top_k: int = 4):
+        """
+        Public interface: Inpaint/reassemble top-k ranked trajectories from windowed cost.
+        
+        Args:
+            traj: [B, T, D] normalized trajectory
+            traj_type: "joint" or "ee"
+        Returns:
+            recombined_trajs: [top_k**num_windows, T, D] (normalized)
+        """
+        traj, joint_traj, valid_mask = self._prepare_trajectory_inputs(
+            traj,
+            traj_type
+        )
+        
+        # Compute cost and call recombination logic
+        ranking_ids, sdf_cost = self._rank_joint_trajectory_by_cost(joint_traj)
+        recombined_trajs = self._reassemble_from_windows(traj, sdf_cost, num_windows, top_k)
+
+        # Repeat and fill
+        original_B = valid_mask.shape[0]
+        valid_B = recombined_trajs.shape[0]
+
+        if valid_B == 0:
+            raise RuntimeError("All trajectories are invalid. Cannot inpaint.")
+
+        repeat_factor = (original_B + valid_B - 1) // valid_B
+        tiled_trajs = recombined_trajs.repeat((repeat_factor, 1, 1))
+        filled_trajs = tiled_trajs[:original_B]
+        return filled_trajs
+    
+    def keep_top_k_and_expand(self, x_sorted: torch.Tensor, k: int) -> torch.Tensor:
+        """
+        Args:
+            x_sorted: [B, T, D] batch of trajectories sorted by cost (ascending)
+            k: number of top trajectories to keep
+        Returns:
+            x_top: [B, T, D] — top-k repeated to fill B if k < B
+        """
+        B = x_sorted.shape[0]
+        x_top_k = x_sorted[:k]  # [k, T, D]
+
+        if k == B:
+            return x_top_k
+
+        # Repeat to fill B
+        repeat_factor = (B + k - 1) // k  # ceil(B / k)
+        x_repeated = x_top_k.repeat((repeat_factor, 1, 1))  # [ceil* k, T, D]
+        x_padded = x_repeated[:B]  # Trim to [B, T, D]
+
+        return x_padded
+
+    def _prepare_trajectory_inputs(
+        self,
+        traj: torch.Tensor,
+        traj_type: str,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Args:
+            traj: [B, T, D] normalized
+            traj_type: "ee" or "joint"
+        Returns:
+            traj: filtered normalized traj [B', T, D]
+            joint_traj: [B', T, joint_dim]
+            valid_mask: [B]
+        """
+        traj_unnorm = self.dataset.unnormalize_trajectory(traj.clone())
+
+        if traj_type == "ee":
+            B, T = traj_unnorm.shape[:2]
+            ee_pose_ortho6d = traj_unnorm[..., :9].contiguous()
+            ee_pose_quat = transform_ortho6d_to_quat(ee_pose_ortho6d.view(B * T, 9)).view(B, T, 7)
+            joint_traj, valid_mask = self._batch_ik(ee_pose_quat)
+        elif traj_type == "joint":
+            joint_traj = traj_unnorm
+            valid_mask = torch.ones(traj.shape[0], dtype=torch.bool, device=traj.device)
+        else:
+            raise ValueError(f"Unsupported traj_type: {traj_type}")
+        if not valid_mask.any():
+            print("\033[91m[Warning] All trajectories are invalid! Forcing valid_mask = all True.\033[0m")
+            valid_mask = torch.ones_like(valid_mask, dtype=torch.bool)
+
+        return traj[valid_mask], joint_traj[valid_mask], valid_mask
+    
+    def _reassemble_from_windows(self, traj: torch.Tensor, sdf_cost: torch.Tensor, num_windows: int, top_k: int):
+        """
+        Internal logic: select top-k windows based on cost and recombine.
+
+        Args:
+            traj: [B, T, D] normalized trajectory
+            sdf_cost: [B, T, S] full sdf cost per trajectory
+        Returns:
+            recombined_trajs: [top_k**num_windows, T, D] (normalized)
+        """
+        B, T, D = traj.shape
+        window_size = T // num_windows
+        assert T % num_windows == 0, "Trajectory length T must be divisible by num_windows"
+
+        top_segments_per_window = []
+
+        for w in range(num_windows):
+            t_start = w * window_size
+            t_end = (w + 1) * window_size
+
+            window_cost = sdf_cost[:, t_start:t_end, :].sum(dim=(1, 2))  # [B]
+            top_k_ids = torch.argsort(window_cost, dim=0)[:top_k]
+            top_k_segments = traj[top_k_ids, t_start:t_end, :]  # from normalized traj
+            top_segments_per_window.append(top_k_segments)
+
+        # Cartesian product recombination
+        import itertools
+        import random
+
+        B = traj.shape[0]  # original batch size
+        all_combinations = list(itertools.product(*top_segments_per_window))
+        random.shuffle(all_combinations)  # optional: for stochasticity
+
+        # Select only the first B combinations
+        selected_combinations = all_combinations[:B]
+        recombined_trajs = [torch.cat(segments, dim=0) for segments in selected_combinations]
+        recombined_trajs = torch.stack(recombined_trajs, dim=0)  # [B, T, D]
+
+        return recombined_trajs.to(traj.device)
+    
+    def _rank_joint_trajectory_by_cost(self, joint_traj: torch.Tensor):
+        sphere_data = self._get_cartesian_positions(joint_traj)
+        sdf_cost = self._calculate_sdf_cost(sphere_data['all_sphere_poses'], sphere_data['all_sphere_radii'])
+        sdf_cost = self._filter_cost_by_mask(sdf_cost, sphere_data['all_sphere_mask'])
+        debug_entry = DebugEntry(
+                sphere_poses=sphere_data['all_sphere_poses'],
+                sphere_radii=sphere_data['all_sphere_radii'],
+                sdf_costs=sdf_cost,
+            )
+        self.debug_state.append(debug_entry)
+
+        total_cost = sdf_cost.sum(dim=(1, 2))  # [B]
+        ranking_ids = torch.argsort(total_cost, dim=0)
+        return ranking_ids, sdf_cost
+    
+    def update_observation(self, obs):
+        self._point_cloud = obs['point_cloud']
+        self._sdf_model.update_pcd(self._point_cloud)
+    
+    def reset(self):
+        self.reset_debug_state()
+
+    def reset_debug_state(self):
+        self.debug_state = []
+    
+    def _batch_ik(self, ee_trajectory: torch.Tensor, max_invalid: int = 3):
+        """
+        Convert end-effector trajectory to joint trajectory using IK.
+        Input: ee_trajectory [B, T, 7]
+        Output: joint_trajs [B, T, D]
+        """
+        ee_np = ee_trajectory.detach().cpu().numpy()
+        B, T = ee_np.shape[:2]
+        joint_dim = len(self._kin_solver.joint_indices)
+        q_trajs = np.zeros((B, T, joint_dim), dtype=np.float32)
+        invalid_ik_counts = np.zeros(B, dtype=np.int32) # count each trajectory invalid ik waypoints, if too much, remove it
+
+        for b in range(B):
+            last_valid_q = None
+            for t in range(T):
+                pose = ee_np[b, t]
+                pose = sapien.Pose(pose[:3], pose[3:])
+
+                if t == 0:
+                    # ik_sol = self._kin_solver.compute_ik(target_pose=pose, initial_qpos=self._get_current_qpos().detach().cpu().numpy())
+                    initial_qpos = self._get_current_qpos().detach().cpu().numpy().reshape(-1)
+                    ik_sol = self._kin_solver.compute_ik(target_pose=pose, initial_qpos=initial_qpos)
+                else:
+                    ik_sol = self._kin_solver.compute_ik(target_pose=pose, initial_qpos=last_valid_q)
+
+                if ik_sol is None:
+                    
+                    # print(f"[IK FAIL] Batch {b}, t={t}, pose={pose}")
+                    invalid_ik_counts[b] += 1
+                    ik_sol = last_valid_q.copy() if last_valid_q is not None else np.zeros(joint_dim, dtype=np.float32)
+
+                q_trajs[b, t] = ik_sol
+                last_valid_q = ik_sol
+                
+        valid_mask = invalid_ik_counts <= max_invalid
+        # print(f"Invalid IK counts: {invalid_ik_counts}, valid mask: {valid_mask}")
+        return torch.tensor(q_trajs, device=self.device, dtype=self.dtype), torch.from_numpy(valid_mask).to(self.device)
+    
+    def _filter_cost_by_mask(self, cost, sphere_mask):
+        filtered_cost = cost * sphere_mask
+        return filtered_cost
+
+    def _calculate_sdf_cost(self, sphere_poses_tensor, sphere_radii_tensor):
+        assert sphere_poses_tensor.shape[:3] == sphere_radii_tensor.shape
+        batch_size, seq_len, num_spheres, _ = sphere_poses_tensor.shape
+        sphere_positions_flat = einops.rearrange(sphere_poses_tensor, 'b t s d -> b (t s) d')
+        sdf_distance_center = self._sdf_model(sphere_positions_flat)
+        sdf_distance_center = einops.rearrange(sdf_distance_center, 'b (t s) -> b t s', b=batch_size, t=seq_len)
+        # Distance from sphere surface
+        sdf_distance_surface = sdf_distance_center - sphere_radii_tensor
+
+        alpha = 8.0  
+        max_distance = self._max_distance  # should be scalar
+        clipped_distance = torch.clamp_max(sdf_distance_surface, max_distance)
+        sdf_cost = torch.exp(alpha * (max_distance - clipped_distance)) - 1
+        sdf_cost = torch.where(sdf_cost > 0, sdf_cost, torch.zeros_like(sdf_cost))
+        # print("sdf_cost mean:", sdf_cost.mean())
+        # print("sdf_cost max:", sdf_cost.max())
+        # print("sdf_cost min:", sdf_cost.min())
+        return sdf_cost
+    
+    def _get_cartesian_positions(self, joint_states): 
+        # what is the best way to get end-effector poses? shall I wrap the restructure function in this?
+        if isinstance(joint_states, torch.Tensor): # this is not efficient, but let's keep it for now for MVP
+            joint_states = joint_states.detach().cpu().numpy()
+        sphere_poses_list = []
+        sphere_radii_list = []
+        for b in range(joint_states.shape[0]):
+            batch_sphere_poses = []
+            batch_sphere_radii = []
+            for t in range(joint_states.shape[1]):
+                sphere_poses, sphere_radii = self._kin_solver.calculate_all_sphere_positions_and_radii(joint_states[b, t, :])
+                batch_sphere_poses.append(sphere_poses)
+                batch_sphere_radii.append(sphere_radii)
+            sphere_poses_list.append(batch_sphere_poses)
+            sphere_radii_list.append(batch_sphere_radii)
+                
+        restructured_data = self._restructure_sphere_data(sphere_poses_list, sphere_radii_list)
+        return restructured_data
+
+    def _restructure_sphere_data(self, 
+                                 batch_sphere_poses_list: List[List[Dict[str, List[np.ndarray]]]], 
+                                 batch_sphere_radii_list: List[List[Dict[str, List[float]]]]):
+        batch_size = len(batch_sphere_poses_list)
+        seq_len = len(batch_sphere_poses_list[0])
+        spheres_per_link = {link: len(spheres) for link, spheres in batch_sphere_poses_list[0][0].items()}
+        total_spheres = sum(spheres_per_link.values())
+
+        def create_single_qpos_sphere(sphere_pose_list, sphere_radii_list):
+            sphere_poses = torch.zeros((seq_len, total_spheres, 3), device=self.device, dtype=self.dtype)
+            sphere_radii = torch.zeros((seq_len, total_spheres), device=self.device, dtype=self.dtype)
+            for t in range(seq_len):
+                idx = 0
+                for link_name, spheres in sphere_pose_list[t].items():
+                    n = len(spheres)
+                    if n == 0:
+                        continue
+                    radii = sphere_radii_list[t][link_name]
+                    assert n == len(radii), f"Mismatch: {n} spheres vs {len(radii)} radii for {link_name} at t={t}"
+                    sphere_poses[t, idx:idx+n] = torch.from_numpy(np.stack(spheres)).to(device=self.device, dtype=self.dtype)
+                    sphere_radii[t, idx:idx+n] = torch.tensor(radii, device=self.device, dtype=self.dtype)
+                    idx += n
+                assert idx == total_spheres, f"Total spheres mismatch at t={t}"
+            return sphere_poses, sphere_radii
+
+        def create_sphere_mask(sphere_pose_list):
+            mask = torch.zeros((seq_len, total_spheres), device=self.device, dtype=torch.bool)
+            for t in range(seq_len):
+                idx = 0
+                for link_name, spheres in sphere_pose_list[t].items():
+                    n = len(spheres)
+                    if n == 0:
+                        continue
+                    if hasattr(self, '_selected_links') and link_name in self._selected_links:
+                        mask[t, idx:idx+n] = True
+                    idx += n
+                assert idx == total_spheres, f"Total spheres mismatch at t={t}"
+            return mask
+
+        all_sphere_poses_tensor = torch.zeros((batch_size, seq_len, total_spheres, 3), device=self.device, dtype=self.dtype)
+        all_sphere_radii_tensor = torch.zeros((batch_size, seq_len, total_spheres), device=self.device, dtype=self.dtype)
+        # Create the mask only once, using the first batch's structure
+        mask = create_sphere_mask(batch_sphere_poses_list[0])
+        all_sphere_mask_tensor = mask.unsqueeze(0).expand(batch_size, -1, -1).clone()
+
+        for b in range(batch_size):
+            poses, radii = create_single_qpos_sphere(batch_sphere_poses_list[b], batch_sphere_radii_list[b])
+            all_sphere_poses_tensor[b] = poses
+            all_sphere_radii_tensor[b] = radii
+            # No need to recompute mask for each batch
+
+        return {
+            'all_sphere_poses': all_sphere_poses_tensor,
+            'all_sphere_radii': all_sphere_radii_tensor,
+            'all_sphere_mask': all_sphere_mask_tensor,
+        }
+    
+    
+    
+class GuideManagerJacobian(GuideManager):
+    """
+    This class is not working, keep here in case we need it later
+    """
+    def __init__(self,
+                 dataset,
+                 robot_model,
+                 tensor_args,
+                 clip_grad=False, clip_grad_rule='norm',
+                 max_grad_norm=1.0, max_grad_value=1.0,
+                 guidance_weight=0.15
+                 ):
+        super().__init__(dataset,
+                         tensor_args,
+                         clip_grad, clip_grad_rule, 
+                         max_grad_norm, max_grad_value,
+                         guidance_weight)
+        self._point_cloud = None
+        self._sdf_model = PointCloud_CSDF(sphere_radius=0.10, max_distance=0.04, device=self.device, pcd=None)
+        # print("GUIDANCE STRENGTH: ", self.guidance_weight)
+        self._advanced_kinematics_solver = AdvancedKinematicsSolver(robot_model)
+        # self._selected_links = ["panda_link0", "panda_link1", "panda_link2", "panda_link3", 
+                        #    "panda_link4", "panda_link5", "panda_link6", "panda_link7", "panda_link8", "panda_hand"]
+        self._selected_links = ["panda_link5", "panda_link6", "panda_link7", "panda_link8", "panda_hand", "panda_leftfinger", "panda_rightfinger"]
+        # self._selected_links = ["panda_hand"]
+
+        # all the links in the robot: "panda_link0", "panda_link1", "panda_link2", "panda_link3", 
+        # "panda_link4", "panda_link5", "panda_link6", "panda_link7", "panda_link8", "panda_hand"
+        # panda_leftfinger, panda_rightfinger, camera_base_link, camera_link
+        # Dictionary to store debug values that can be accessed from outside
+        self.debug_state = []
+    
+    def update_observation(self, obs):
+        self._point_cloud = obs['point_cloud']
+        self._sdf_model.update_pcd(self._point_cloud)
+    
+    def forward(self, x_normalized):
+        '''
+        In this class, x has to be joint states, not end-effector poses
+        x_normalized: [batch, length, joint_dim]
+
+        Define the pipeline before heading to submodules
+        1. calculate sdf on each sphere
+            a. calculate sphere position
+            b. get direction based on each sphere
+        2. derivative each sphere's direction to delta joint
+            a. get jacobian of each sphere based on current joint position (x)
+            b. calculate derivative
+        3. add joint derivative to each joint
+        '''
+        # start_time = time.time()
+        x_norm = x_normalized.clone() # ⚠️ IMPORTANT: x should be joint states, not end-effector poses
+        x = self.dataset.unnormalize_trajectory(x_norm)
+
+        # Convert tensor x to numpy array for sphere & jacobian calculation
+        x_np = x.detach().cpu().numpy() #TODO: this copy waste resouce, but...will find a better way after MVP works
+        # x shape: [batch, length, joint_dim], joint_dim = 9
+        # CPU version, only choose the first batch
+        sphere_poses_list = []
+        sphere_radii_list = []
+        sphere_jacobians_list = []
+        for i in range(x_np.shape[1]):
+            sphere_poses, sphere_radii = self._advanced_kinematics_solver.calculate_all_sphere_positions_and_radii(x_np[0, i, :]) # un-normalized x_norm, sample spheres
+            sphere_jacobians = self._advanced_kinematics_solver.calculate_all_sphere_jacobian(x_np[0, i, :])
+            sphere_poses_list.append(sphere_poses)
+            sphere_radii_list.append(sphere_radii)
+            sphere_jacobians_list.append(sphere_jacobians)
+        
+        self.debug_state.append({
+            'sphere_poses': sphere_poses_list,
+            'sphere_radii': sphere_radii_list,
+        })
+
+        joint_guidance = self._calculate_sdf_guidance(sphere_poses_list, sphere_radii_list, sphere_jacobians_list) #[batch, length, joint_dim]
+
+        # Calculate statistics for each joint dimension
+        joint_guidance_mean = torch.mean(joint_guidance, dim=(0,1))  # Average across batch and time
+        joint_guidance_std = torch.std(joint_guidance, dim=(0,1))   # Std across batch and time
+        joint_guidance_max = torch.amax(joint_guidance, dim=(0,1))
+        joint_guidance_min = torch.amin(joint_guidance, dim=(0,1))
+
+        # print("\nJoint Guidance Statistics (UnNormalized):")
+        # if torch.any(joint_guidance_mean != 0):
+        #     print(f"Mean per joint: {joint_guidance_mean}")
+        # if torch.any(joint_guidance_std != 0):
+        #     print(f"Std per joint: {joint_guidance_std}")
+        # if torch.any(joint_guidance_max != 0):
+        #     print(f"Max per joint: {joint_guidance_max}")
+        # if torch.any(joint_guidance_min != 0):
+        #     print(f"Min per joint: {joint_guidance_min}")
+
+        joint_guidance_normalized = self.dataset.normalizer.normalize(joint_guidance, self.dataset.data_key_traj)
+
+        # print("\nJoint Guidance Statistics (Normalized):")
+        joint_guidance_norm_mean = torch.mean(joint_guidance_normalized, dim=(0,1))
+        joint_guidance_norm_std = torch.std(joint_guidance_normalized, dim=(0,1))
+        joint_guidance_norm_max = torch.amax(joint_guidance_normalized, dim=(0,1))
+        joint_guidance_norm_min = torch.amin(joint_guidance_normalized, dim=(0,1))
+
+        # if torch.any(joint_guidance_norm_mean != 0):
+        #     print(f"Mean per joint: {joint_guidance_norm_mean}")
+        # if torch.any(joint_guidance_norm_std != 0):
+        #     print(f"Std per joint: {joint_guidance_norm_std}")
+        # if torch.any(joint_guidance_norm_max != 0):
+        #     print(f"Max per joint: {joint_guidance_norm_max}")
+        # if torch.any(joint_guidance_norm_min != 0):
+        #     print(f"Min per joint: {joint_guidance_norm_min}")
+        
+        # end_time = time.time()
+        # print(f"GuideManagerJointStates.forward execution time: {end_time - start_time:.4f} seconds")
+        # return joint_guidance_normalized
+        return self.guidance_weight*joint_guidance
+
+    def _calculate_sdf_guidance(self, 
+                          sphere_poses_list: List[Dict[str, List[np.ndarray]]], 
+                          sphere_radii_list: List[Dict[str, List[float]]],
+                          sphere_jacobians_list: List[Dict[str, List[np.ndarray]]]):
+        batch_size = 1
+        
+        restructured_data = self._restructure_sphere_data(batch_size, sphere_poses_list, sphere_jacobians_list, sphere_radii_list)
+        
+        # calculate sdf distance
+        all_sphere_positions = restructured_data['sphere_poses']
+        # reshape to [batch, seq_len*spheres_per_timestep, 3]
+        all_sphere_positions = einops.rearrange(all_sphere_positions, 'b s n d -> b (s n) d')
+        
+        # Only set requires_grad for the positions tensor
+        all_sphere_positions.requires_grad_(True)
+        
+        # print("all_sphere_positions shape: ", all_sphere_positions.shape)
+        with torch.enable_grad():
+            sdf_values = self._sdf_model(all_sphere_positions) #[batch, seq_len*spheres_per_timestep]
+            # Reshape sdf_values back to [batch, seq_len, spheres_per_timestep]
+            # sdf_values = einops.rearrange(sdf_values, 'b (s n) -> b s n', 
+            #                      b=batch_size,  # batch size
+            #                      s=len(sphere_poses_list))  # sequence length
+            # print("sdf_values shape: ", sdf_values.shape)
+            
+            # Compute gradients only for the positions
+            sdf_values.sum().backward()
+            sdf_gradient = all_sphere_positions.grad  # Get gradient from positions tensor, shape: [batch, seq_len*spheres_per_timestep, 3]
+
+        
+
+        sdf_gradient = einops.rearrange(sdf_gradient, 'b (s n) d -> b s n d', 
+                                 b=batch_size,  # batch size
+                                 s=len(sphere_poses_list))  # sequence length
+        
+        sphere_mask = restructured_data['sphere_mask']
+        # print("sdf gradient shape: ", sdf_gradient.shape)
+        # print("sphere mask shape: ", sphere_mask.shape)
+        sdf_gradient = sdf_gradient * sphere_mask.unsqueeze(-1)
+
+        alpha = 2.5
+        norms = torch.norm(sdf_gradient, dim=-1, keepdim=True)
+        weights = torch.exp(-alpha * norms)
+        # print("weights shape: ", weights.shape)
+        # print("sdf_gradient shape: ", sdf_gradient.shape)
+        sdf_gradient_weighted = sdf_gradient * weights
+        sdf_gradient_weighted = torch.clamp(sdf_gradient_weighted, min=-0.1, max=0.1)
+        
+        # Debug feature: zero out gradients for sphere indices <= 10
+        # self.debug_only_spheres_gt_10 = True
+        # if hasattr(self, 'debug_only_spheres_gt_10') and self.debug_only_spheres_gt_10:
+        #     mask = torch.zeros_like(sdf_gradient_weighted)
+        #     mask[..., 19:, :] = 1  # keep only spheres with index > 10
+        #     sdf_gradient_weighted = sdf_gradient_weighted * mask
+        
+        self.debug_state.append({
+            'sdf_gradients': sdf_gradient_weighted,
+        })
+
+        # Only rearrange if not already 5D
+        if sdf_gradient_weighted.dim() == 4:
+            sdf_gradient_weighted = einops.rearrange(sdf_gradient_weighted, 'b t s d -> b t s 1 d')
+
+        joint_guidance = self._calculate_joint_guidance_from_sphere_sdf(restructured_data, sdf_gradient_weighted)
+        return joint_guidance
+
+    def _restructure_sphere_data(self, 
+                           batch_size: int,
+                           sphere_poses_list: List[Dict[str, List[np.ndarray]]],
+                           sphere_jacobians_list: List[Dict[str, List[np.ndarray]]],
+                           sphere_radii_list: List[Dict[str, List[float]]]) -> Dict[str, torch.Tensor]:
+        
+        seq_len = len(sphere_poses_list)
+        # Get unique link names and create mappings
+        link_names = list(sphere_poses_list[0].keys())
+
+        # Count total spheres per link across all timesteps
+        spheres_per_link = {link: len(spheres) for link, spheres in sphere_poses_list[0].items()}
+        total_spheres = sum(spheres_per_link.values())
+
+        # Create link to sphere mapping
+        # link_to_spheres = {}
+        # current_idx = 0
+        # for link, num_spheres in spheres_per_link.items():
+        #     link_to_spheres[link] = list(range(current_idx, current_idx + num_spheres))
+        #     current_idx += num_spheres
+
+        # Initialize tensors
+        sphere_poses = torch.zeros((batch_size, seq_len, total_spheres, 3), 
+                                device=self.device, dtype=self.dtype)
+        jacobians = torch.zeros((batch_size, seq_len, total_spheres, 6, sphere_jacobians_list[0][link_names[0]][0].shape[-1]), 
+                            device=self.device, dtype=self.dtype)
+        sphere_radii = torch.zeros((batch_size, seq_len, total_spheres),
+                                device=self.device, dtype=self.dtype)
+        sphere_mask = torch.zeros((batch_size, seq_len, total_spheres), 
+                                device=self.device, dtype=torch.bool)
+
+        # Fill tensors
+        for t in range(seq_len):
+            current_sphere_idx = 0
+            for link_name, spheres in sphere_poses_list[t].items():
+                if len(spheres) == 0:
+                    continue
+                    
+                # Convert positions to tensor
+                spheres_tensor = torch.from_numpy(np.stack(spheres)).to(
+                    device=self.device, dtype=self.dtype)
+                sphere_poses[0, t, current_sphere_idx:current_sphere_idx + len(spheres)] = spheres_tensor
+                
+                # Get corresponding jacobians
+                link_jacobians = sphere_jacobians_list[t][link_name]
+                jacobians[0, t, current_sphere_idx:current_sphere_idx + len(spheres)] = torch.from_numpy(
+                    np.stack(link_jacobians)
+                ).to(device=self.device, dtype=self.dtype)
+                
+                # Get corresponding radii
+                radii = sphere_radii_list[t][link_name]
+                sphere_radii[0, t, current_sphere_idx:current_sphere_idx + len(spheres)] = torch.tensor(
+                    radii, device=self.device, dtype=self.dtype)
+                
+                # Set mask to True if link is in selected_links
+                if hasattr(self, '_selected_links') and link_name in self._selected_links:
+                    sphere_mask[0, t, current_sphere_idx:current_sphere_idx + len(spheres)] = True
+                
+                current_sphere_idx += len(spheres)
+        
+        return {
+            'sphere_poses': sphere_poses,  # [batch, timestep, sphere_number, 3]
+            'jacobians': jacobians,        # [batch, timestep, sphere_number, 6, n_joints]
+            'sphere_radii': sphere_radii,  # [batch, timestep, sphere_number]
+            'sphere_mask': sphere_mask     # [batch, timestep, sphere_number]
+        }
+
+    def _calculate_joint_guidance_from_sphere_sdf(self, 
+                                            restructured_data: Dict[str, torch.Tensor],
+                                            sdf_gradient_weighted: torch.Tensor) -> torch.Tensor:
+        """
+        Calculate joint guidance from sphere SDF gradients using parallel computation.
+        
+        Returns:
+            Joint guidance tensor of shape [num_joints]
+        """
+        # Extract data
+        sphere_jacobians = restructured_data['jacobians']  #
+        sphere_mask = restructured_data['sphere_mask']  # 
+
+        position_jacobian = sphere_jacobians[:, :, :, :3, :]  # [batch, timestep, sphere_number, 3, 9]
+        # From [batch, timestep, sphere_number, 3] to [batch, timestep, sphere_number, 1, 3]
+
+        # Print statistics about sdf_gradients_unsq
+        # print("SDF gradients shape:", sdf_gradient_weighted.shape)
+        # print("SDF gradients mean (per component):", sdf_gradient_weighted.mean(dim=(0,1,2)))
+        # print("SDF gradients std (per component):", sdf_gradient_weighted.std(dim=(0,1,2)))
+        # print("SDF gradients min (per component):", sdf_gradient_weighted.amin(dim=(0,1,2)))
+        # print("SDF gradients max (per component):", sdf_gradient_weighted.amax(dim=(0,1,2)))
+
+        # The multiplication / mask stuff here needs tobe double checked, I don't think it is correct
+        # 2. Matrix multiply (no einops needed here)
+        joint_grads = torch.matmul(sdf_gradient_weighted, position_jacobian)  # [b, t, s, 1, j]
+        
+        # 3. Remove singleton (now [b, t, s, j])
+        joint_grads = einops.rearrange(joint_grads, 'b t s 1 j -> b t s j')
+
+        # a no mask version
+        # Sum over sphere_number (axis s) to get final joint deltas:
+        delta_joint_states = einops.reduce(joint_grads, 'b t s j -> b t j', 'sum')
+
+        delta_joint_states = torch.clamp(delta_joint_states, min=-0.1, max=0.1)
+
+        # # 4. Mask broadcast ([s, j] -> [1, 1, s, j])
+        # # TODO: jacobian mask
+        # mask_broadcast = einops.rearrange(mask, 's j -> 1 1 s j')
+        # joint_grads = joint_grads * mask_broadcast
+        
+        return delta_joint_states
+
+        
+        

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/helpers.py

@@ -0,0 +1,109 @@
+"""
+Adapted from https://github.com/joaoamcarvalho/mpd-public
+"""
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+
+#-----------------------------------------------------------------------------#
+#---------------------------- variance schedules -----------------------------#
+#-----------------------------------------------------------------------------#
+
+def linear_beta_schedule(n_diffusion_steps, beta_start=0.0001, beta_end=0.02):
+    return torch.linspace(beta_start, beta_end, n_diffusion_steps)
+
+
+def quadratic_beta_schedule(n_diffusion_steps, beta_start=0.0001, beta_end=0.02):
+    return torch.linspace(beta_start**0.5, beta_end**0.5, n_diffusion_steps) ** 2
+
+
+def sigmoid_beta_schedule(n_diffusion_steps, beta_start=0.0001, beta_end=0.02):
+    betas = torch.linspace(-6, 6, n_diffusion_steps)
+    return torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
+
+
+def cosine_beta_schedule(n_diffusion_steps, s=0.008, a_min=0, a_max=0.999, dtype=torch.float32):
+    """
+    cosine schedule
+    as proposed in https://openreview.net/forum?id=-NEXDKk8gZ
+    """
+    steps = n_diffusion_steps + 1
+    x = np.linspace(0, steps, steps)
+    alphas_cumprod = np.cos(((x / steps) + s) / (1 + s) * np.pi * 0.5) ** 2
+    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
+    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
+    betas_clipped = np.clip(betas, a_min=a_min, a_max=a_max)
+    return torch.tensor(betas_clipped, dtype=dtype)
+
+
+def exponential_beta_schedule(n_diffusion_steps, beta_start=1e-4, beta_end=1.0):
+    # exponential increasing noise from t=0 to t=T
+    x = torch.linspace(0, n_diffusion_steps, n_diffusion_steps)
+    beta_start = torch.tensor(beta_start)
+    beta_end = torch.tensor(beta_end)
+    a = 1 / n_diffusion_steps * torch.log(beta_end / beta_start)
+    betas = beta_start * torch.exp(a * x)
+    return torch.clamp(betas, max=beta_end)  # Ensure values don't exceed beta_end
+
+
+def constant_fraction_beta_schedule(n_diffusion_steps):
+    # exponential increasing noise from t=0 to t=T
+    x = torch.linspace(0, n_diffusion_steps, n_diffusion_steps)
+    return 1 / (n_diffusion_steps-x+1)
+
+
+def variance_preserving_beta_schedule(n_diffusion_steps, beta_start=1e-4, beta_end=1.0):
+    # Works only with a small number of diffusion steps
+    # https://arxiv.org/abs/2112.07804
+    # https://openreview.net/pdf?id=AHvFDPi-FA
+    x = torch.linspace(0, n_diffusion_steps, n_diffusion_steps)
+    alphas = torch.exp(-beta_start*(1/n_diffusion_steps) - 0.5*(beta_end-beta_start)*(2*x-1)/(n_diffusion_steps**2))
+    betas = 1 - alphas
+    return betas
+
+
+
+
+#-----------------------------------------------------------------------------#
+#---------------------------------- losses -----------------------------------#
+#-----------------------------------------------------------------------------#
+
+class WeightedLoss(nn.Module):
+
+    def __init__(self, weights=None):
+        super().__init__()
+        self.register_buffer('weights', weights)
+
+    def forward(self, pred, targ):
+        '''
+            pred, targ : tensor
+                [ batch_size x horizon x transition_dim ]
+        '''
+        loss = self._loss(pred, targ)
+        if self.weights is not None:
+            weighted_loss = (loss * self.weights).mean()
+        else:
+            weighted_loss = loss.mean()
+        return weighted_loss, {}
+
+
+class WeightedL1(WeightedLoss):
+
+    def _loss(self, pred, targ):
+        return torch.abs(pred - targ)
+
+
+class WeightedL2(WeightedLoss):
+
+    def _loss(self, pred, targ):
+        return F.mse_loss(pred, targ, reduction='none')
+
+
+Losses = {
+    'l1': WeightedL1,
+    'l2': WeightedL2,
+}
+
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/mlp_model.py

@@ -0,0 +1,56 @@
+from torch import nn
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from einops.layers.torch import Rearrange
+
+
+## Fully connected Neural Network block - Multi Layer Perceptron
+class MLP(nn.Module):
+    def __init__(self, in_dim, out_dim, hidden_dim=16, n_layers=1, act='relu', batch_norm=True):
+        super(MLP, self).__init__()
+        activations = {'relu': nn.ReLU, 'sigmoid': nn.Sigmoid, 'tanh': nn.Tanh, 'leaky_relu': nn.LeakyReLU,
+                       'elu': nn.ELU, 'prelu': nn.PReLU, 'softplus': nn.Softplus, 'mish': nn.Mish,
+                       'identity': nn.Identity
+                       }
+
+        act_func = activations[act]
+        layers = [nn.Linear(in_dim, hidden_dim), act_func()]
+        for i in range(n_layers):
+            layers += [
+                nn.Linear(hidden_dim, hidden_dim),
+                nn.BatchNorm1d(hidden_dim) if batch_norm else nn.Identity(),
+                act_func(),
+            ]
+        layers.append(nn.Linear(hidden_dim, out_dim))
+
+        self._network = nn.Sequential(
+            *layers
+        )
+
+    def forward(self, x):
+        return self._network(x)
+
+
+
+class MLPModel(nn.Module):
+    def __init__(self, in_dim=16, out_dim=16, input_field='x',
+                 output_field='y',
+                 pretrained_dir=None,
+                 **kwargs):
+        super().__init__()
+
+        self.input_field = input_field
+        self.output_field = output_field
+
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+
+        self._net = MLP(in_dim, out_dim, **kwargs)
+
+    def forward(self, input):
+        x = input[self.input_field]
+        out = self._net(x)
+        return {self.output_field: out}

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/sample_functions.py

@@ -0,0 +1,286 @@
+import torch
+from matplotlib import pyplot as plt
+import time
+from cfdp.diffusion_policy.utils.utils import to_numpy
+
+def apply_hard_conditioning(x, conditions):
+    for t, val in conditions.items():
+        # print("x: ", x.shape)
+        # print("val: ", val.shape)
+        x[:, t, :] = val.clone()
+    return x
+
+
+def extract(a, t, x_shape):
+    b, *_ = t.shape
+    out = a.gather(-1, t)
+    return out.reshape(b, *((1,) * (len(x_shape) - 1)))
+
+
+@torch.no_grad()
+def ddpm_sample_fn(
+        model, x, hard_conds, context, t,
+        guide=None,
+        n_guide_steps=1,
+        scale_grad_by_std=False,
+        t_start_guide=torch.inf,
+        noise_std_extra_schedule_fn=None,  # 'linear'
+        debug=False,
+        **kwargs
+):
+    t_single = t[0]
+    if t_single < 0:
+        t = torch.zeros_like(t)
+
+    model_mean, _, model_log_variance = model.p_mean_variance(x=x, hard_conds=hard_conds, context=context, t=t)
+    x = model_mean
+    # DEBUG Store the current state, timestep, and reconstruction todo: if debug
+    if debug:
+        if context is not None:
+                context_temp = model.context_model(context)
+        noise_temp = model.model(x, t, context_temp['condition'])
+        model.diffusion_history.append({
+            't': to_numpy(t),
+            'x': to_numpy(model_mean),
+            'noise': to_numpy(-1*noise_temp)
+        })
+
+    model_log_variance = extract(model.posterior_log_variance_clipped, t, x.shape)
+    model_std = torch.exp(0.5 * model_log_variance)
+    model_var = torch.exp(model_log_variance)
+
+    if guide is not None and t_single < t_start_guide:
+
+        x, grad_scaled_lst = guide_gradient_steps(
+            x,
+            hard_conds=hard_conds,
+            guide=guide,
+            n_guide_steps=n_guide_steps,
+            scale_grad_by_std=False,
+            model_var=model_var,
+        )
+        if debug:
+            model.grad_scaled_history.append({
+                't': to_numpy(t_single),
+                'x': to_numpy(model_mean),
+                'grad_scaled': to_numpy(grad_scaled_lst[0])
+            })
+    # no noise when t == 0
+    noise = torch.randn_like(x)
+    noise[t == 0] = 0
+
+    # For smoother results, we can decay the noise standard deviation throughout the diffusion
+    # this is roughly equivalent to using a temperature in the prior distribution
+    if noise_std_extra_schedule_fn is None:
+        noise_std = 1.0
+    else:
+        noise_std = noise_std_extra_schedule_fn(t_single)
+    values = None
+    return x + model_std * noise * noise_std, values
+
+
+@torch.no_grad()
+def ddpm_sample_fn_stomp(
+        model, x, hard_conds, context, t,
+        guide=None,
+        n_guide_steps=1,
+        scale_grad_by_std=False,
+        t_start_guide=torch.inf,
+        noise_std_extra_schedule_fn=None,  # 'linear'
+        debug=False,
+        **kwargs
+):
+    t_single = t[0]
+    if t_single < 0:
+        t = torch.zeros_like(t)
+
+    model_mean, _, model_log_variance = model.p_mean_variance(x=x, hard_conds=hard_conds, context=context, t=t)
+    x = model_mean
+    # DEBUG Store the current state, timestep, and reconstruction todo: if debug
+    if debug:
+        if context is not None:
+                context_temp = model.context_model(context)
+        noise_temp = model.model(x, t, context_temp['condition'])
+        model.diffusion_history.append({
+            't': to_numpy(t),
+            'x': to_numpy(model_mean),
+            'noise': to_numpy(-1*noise_temp)
+        })
+
+    model_log_variance = extract(model.posterior_log_variance_clipped, t, x.shape)
+    model_std = torch.exp(0.5 * model_log_variance)
+    model_var = torch.exp(model_log_variance)
+
+
+    # if guide is not None and t_single in [1, 0]:
+    #     k = min(2, x.shape[0])
+    #     # x = inject_noise_to_mean(x, std=0.08)
+    #     x = select_best_trajectories(x, guide, k)
+    #     # x = smooth_trajectory_batch(x, weight=0.99)
+    #     print("x.shape:", x.shape)
+    
+    if guide is not None and t_single < t_start_guide:
+        x, grad_scaled_lst = guide_gradient_steps(
+            x,
+            hard_conds=hard_conds,
+            guide=guide,
+            n_guide_steps=n_guide_steps,
+            scale_grad_by_std=scale_grad_by_std,
+            model_var=model_var,
+        )
+        
+        if debug:
+            model.grad_scaled_history.append({
+                't': to_numpy(t_single),
+                'x': to_numpy(model_mean),
+                'grad_scaled': to_numpy(grad_scaled_lst[0])
+            })
+            
+    # no noise when t == 0
+    noise = torch.randn_like(x)
+    noise[t == 0] = 0
+
+    # For smoother results, we can decay the noise standard deviation throughout the diffusion
+    # this is roughly equivalent to using a temperature in the prior distribution
+    if noise_std_extra_schedule_fn is None:
+        noise_std = 1.0
+    else:
+        noise_std = noise_std_extra_schedule_fn(t_single)
+    values = None
+
+    return x + model_std * noise * noise_std, values
+
+def select_best_trajectories(x, guide, k=2):
+    guide(x, get_cost_rank=True)  # [batch]
+    sorted_indices = guide.sdf_cost_sorted_indices[:k]  # [k]
+    x_selected = x[sorted_indices]  # [k, seq_len, joint_dim]
+    batch = x.shape[0]
+    if k == 0:
+        raise ValueError("No trajectories selected (k=0).")
+        
+    # Randomly sample k trajectories to create batch_size trajectories
+    indices = torch.randint(0, k, (batch,), device=x_selected.device)  # [batch]
+    x_new = x_selected[indices]  # [batch, seq_len, joint_dim]
+    return x_new
+
+def guide_with_selection(x,
+    hard_conds=None,
+    guide=None,
+    n_guide_steps=1, scale_grad_by_std=False,
+    model_var=None,
+    k=2,
+    **kwargs
+):
+    grad_scaled_lst = []
+    x_new = select_best_trajectories(x, guide, k)
+
+    # Apply gradient steps
+    for step in range(n_guide_steps):
+        grad_scaled = guide(x_new, get_cost_rank=True)
+        if scale_grad_by_std:
+            grad_scaled = model_var * grad_scaled
+        x = x + grad_scaled
+        x = apply_hard_conditioning(x, hard_conds)
+        grad_scaled_lst.append(grad_scaled)
+    
+    return x, grad_scaled_lst
+
+def guide_gradient_steps(
+    x,
+    hard_conds=None,
+    guide=None,
+    n_guide_steps=1, scale_grad_by_std=False,
+    model_var=None,
+    **kwargs
+):
+    grad_scaled_lst = []
+    for step in range(n_guide_steps):
+        grad_scaled = guide(x)
+        # print("grad_scaled: ", grad_scaled)
+        if scale_grad_by_std:
+            grad_scaled = model_var * grad_scaled
+        # print("grad_scaled: ", grad_scaled)
+        x = x + grad_scaled
+        x = apply_hard_conditioning(x, hard_conds)
+        grad_scaled_lst.append(grad_scaled)
+    
+    return x, grad_scaled_lst
+
+def smooth_trajectory_batch(traj: torch.Tensor, weight: float = 0.4) -> torch.Tensor:
+    traj_smooth = traj.clone()
+    # Smooth all inner waypoints by blending with neighbors
+    traj_smooth[:, 1:-1, :] = (
+        (1 - weight) * traj[:, 1:-1, :]
+        + (weight / 2) * (traj[:, :-2, :] + traj[:, 2:, :])
+    )
+    return traj_smooth
+
+def inject_stomp_noise(x: torch.Tensor, num_samples: int = 2, std: float = 0.1) -> torch.Tensor:
+    """
+    Randomly select a subset of trajectories from x and add Gaussian noise (STOMP-style).
+    Args:
+        x: torch.Tensor of shape [batch, seq_len, joint_dim] or similar
+            The batch of trajectories or states to be perturbed.
+        num_samples: int, optional (default=2)
+            Number of trajectories to add noise to.
+        std: float, optional (default=0.1)
+            Standard deviation of the Gaussian noise to be added.
+    Returns:
+        x_noisy: torch.Tensor of the same shape as x,
+            with selected trajectories perturbed.
+        selected_indices: torch.Tensor containing the indices of the perturbed trajectories.
+    """
+    x_noisy = x.clone()
+    batch_size, seq_len, joint_dim = x.shape
+    device = x.device
+    # Select random indices
+    selected_indices = torch.randperm(batch_size, device=device)[:num_samples]
+
+    # Create time weights: [seq_len, 1], e.g., sin(pi * t)
+    t = torch.linspace(0, 1, seq_len, device=device)
+    time_weights = torch.sin(t * torch.pi).unsqueeze(1)  # shape: [seq_len, 1]
+
+    # Generate Gaussian noise and apply time-based weights
+    noise = torch.randn((num_samples, seq_len, joint_dim), device=device) * std
+    noise *= time_weights  # Broadcast [seq_len, 1] to [num_samples, seq_len, joint_dim]
+
+    # Inject into selected trajectories
+    x_noisy[selected_indices] += noise
+
+    return x_noisy, selected_indices
+
+def inject_noise_to_mean(x: torch.Tensor, std: float = 0.1) -> torch.Tensor:
+    """
+    Compute mean trajectory and add noise to copies of it.
+    Args:
+        x: torch.Tensor of shape [batch, seq_len, joint_dim] or similar
+            The batch of trajectories or states.
+        std: float, optional (default=0.1)
+            Standard deviation of the Gaussian noise to be added.
+    Returns:
+        x_noisy: torch.Tensor of the same shape as x,
+            with noisy copies of the mean trajectory.
+    """
+    batch_size, seq_len, joint_dim = x.shape
+    device = x.device
+
+    # Compute mean trajectory across batch dimension
+    mean_traj = x.mean(dim=0, keepdim=True)  # [1, seq_len, joint_dim]
+    
+    # Expand mean trajectory to match batch size
+    mean_traj = mean_traj.expand(batch_size, -1, -1)  # [batch, seq_len, joint_dim]
+
+    # Create time weights: [seq_len, 1], e.g., sin(pi * t)
+    t = torch.linspace(0, 1, seq_len, device=device)
+    time_weights = torch.sin(t * torch.pi).unsqueeze(1)  # shape: [seq_len, 1]
+    print("time_weights:", time_weights)
+    
+
+    # Generate Gaussian noise and apply time-based weights
+    noise = torch.randn((batch_size, seq_len, joint_dim), device=device) * std
+    noise *= time_weights  # Broadcast [seq_len, 1] to [batch_size, seq_len, joint_dim]
+
+    # Add noise to the mean trajectory copies
+    x_noisy = mean_traj + noise
+
+    return x_noisy

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/models/temporal_unet.py

@@ -0,0 +1,370 @@
+"""
+Adapted from https://github.com/joaoamcarvalho/mpd-public
+"""
+import einops
+import numpy as np
+import torch
+import torch.nn as nn
+from abc import ABC
+from einops import rearrange
+from torch.nn import DataParallel
+
+from cfdp.diffusion_policy.layers.layers import Downsample1d, Conv1dBlock, Upsample1d, \
+    ResidualTemporalBlock, FiLMResidualTemporalBlock, TimeEncoder, MLP, group_norm_n_groups, LinearAttention, PreNorm, Residual, TemporalBlockMLP
+from cfdp.diffusion_policy.layers.layers_attention import SpatialTransformer
+
+
+UNET_DIM_MULTS = {
+    0: (1, 2, 4),
+    1: (1, 2, 4, 8),
+    2: (1, 2, 4, 8, 16)
+}
+
+class TemporalUnet(nn.Module):
+
+    def __init__(
+            self,
+            n_support_points=None,
+            state_dim=None,
+            unet_input_dim=32,
+            dim_mults=(1, 2, 4, 8),
+            time_emb_dim=32,
+            self_attention=False,
+            conditioning_embed_dim=4,
+            conditioning_type=None,
+            attention_num_heads=2,
+            attention_dim_head=32,
+            **kwargs
+    ):
+        super().__init__()
+
+        self.state_dim = state_dim
+        input_dim = state_dim
+
+        # Conditioning
+        if conditioning_type is None or conditioning_type == 'None':
+            conditioning_type = None
+        elif conditioning_type == 'concatenate':
+            if self.state_dim < conditioning_embed_dim // 4:
+                # Embed the state in a latent space HxF if the conditioning embedding is much larger than the state
+                state_emb_dim = conditioning_embed_dim // 4
+                self.state_encoder = MLP(state_dim, state_emb_dim, hidden_dim=state_emb_dim//2, n_layers=1, act='mish')
+            else:
+                state_emb_dim = state_dim
+                self.state_encoder = nn.Identity()
+            input_dim = state_emb_dim + conditioning_embed_dim
+        elif conditioning_type == 'attention':
+            pass
+        elif conditioning_type == 'default':
+            pass
+        else:
+            raise NotImplementedError
+        self.conditioning_type = conditioning_type
+
+        dims = [input_dim, *map(lambda m: unet_input_dim * m, dim_mults)]
+        in_out = list(zip(dims[:-1], dims[1:]))
+        print(f'[ models/temporal ] Channel dimensions: {in_out}')
+
+        # Networks
+        self.time_mlp = TimeEncoder(32, time_emb_dim)
+
+        # conditioning dimension (time + context)
+        cond_dim = time_emb_dim + (conditioning_embed_dim if conditioning_type == 'default' else 0)
+
+        # Unet
+        self.downs = nn.ModuleList([])
+        self.ups = nn.ModuleList([])
+        num_resolutions = len(in_out)
+
+        for ind, (dim_in, dim_out) in enumerate(in_out):
+            is_last = ind >= (num_resolutions - 1)
+
+            self.downs.append(nn.ModuleList([
+                FiLMResidualTemporalBlock(dim_in, dim_out, cond_dim, n_support_points=n_support_points),
+                FiLMResidualTemporalBlock(dim_out, dim_out, cond_dim, n_support_points=n_support_points),
+                Residual(PreNorm(dim_out, LinearAttention(dim_out))) if self_attention else nn.Identity(),
+                SpatialTransformer(dim_out, attention_num_heads, attention_dim_head, depth=1,
+                                   context_dim=conditioning_embed_dim) if conditioning_type == 'attention' else None,
+                Downsample1d(dim_out) if not is_last else nn.Identity()
+            ]))
+
+            if not is_last:
+                n_support_points = n_support_points // 2
+
+        mid_dim = dims[-1]
+        self.mid_block1 = FiLMResidualTemporalBlock(mid_dim, mid_dim, cond_dim, n_support_points=n_support_points)
+        self.mid_attn = Residual(PreNorm(mid_dim, LinearAttention(mid_dim))) if self_attention else nn.Identity()
+        self.mid_attention = SpatialTransformer(mid_dim, attention_num_heads, attention_dim_head, depth=1,
+                                                context_dim=conditioning_embed_dim) if conditioning_type == 'attention' else nn.Identity()
+        self.mid_block2 = ResidualTemporalBlock(mid_dim, mid_dim, cond_dim, n_support_points=n_support_points)
+
+        for ind, (dim_in, dim_out) in enumerate(reversed(in_out[1:])):
+            is_last = ind >= (num_resolutions - 1)
+
+            self.ups.append(nn.ModuleList([
+                FiLMResidualTemporalBlock(dim_out * 2, dim_in, cond_dim, n_support_points=n_support_points),
+                FiLMResidualTemporalBlock(dim_in, dim_in, cond_dim, n_support_points=n_support_points),
+                Residual(PreNorm(dim_in, LinearAttention(dim_in))) if self_attention else nn.Identity(),
+                SpatialTransformer(dim_in, attention_num_heads, attention_dim_head, depth=1,
+                                   context_dim=conditioning_embed_dim) if conditioning_type == 'attention' else None,
+                Upsample1d(dim_in) if not is_last else nn.Identity()
+            ]))
+
+            if not is_last:
+                n_support_points = n_support_points * 2
+
+        self.final_conv = nn.Sequential(
+            Conv1dBlock(unet_input_dim, unet_input_dim, kernel_size=5, n_groups=group_norm_n_groups(unet_input_dim)),
+            nn.Conv1d(unet_input_dim, state_dim, 1),
+        )
+
+    def forward(self, x, time, context):
+        """
+        x : [ batch x horizon x state_dim ]
+        context: [batch x context_dim]
+        """
+        b, h, d = x.shape
+
+        t_emb = self.time_mlp(time)
+        c_emb = t_emb
+        
+        if self.conditioning_type == 'concatenate':
+            x_emb = self.state_encoder(x)
+            context = einops.repeat(context, 'm n -> m h n', h=h)
+            x = torch.cat((x_emb, context), dim=-1)
+        elif self.conditioning_type == 'attention':
+            # reshape to keep the interface
+            context = einops.rearrange(context, 'b d -> b 1 d')
+        elif self.conditioning_type == 'default':
+            # Ensure context has the same shape as t_emb for concatenation
+            c_emb = torch.cat((t_emb, context), dim=-1)
+
+
+        # swap horizon and channels (state_dim)
+        x = einops.rearrange(x, 'b h c -> b c h')  # batch, horizon, channels (state_dim)
+
+        h = []
+        for resnet, resnet2, attn_self, attn_conditioning, downsample in self.downs:
+            x = resnet(x, c_emb)
+            # if self.conditioning_type == 'attention':
+            #     x = attention1(x, context=conditioning_emb)
+            x = resnet2(x, c_emb)
+            x = attn_self(x)
+            if self.conditioning_type == 'attention':
+                x = attn_conditioning(x, context=context)
+            h.append(x)
+            x = downsample(x)
+
+        x = self.mid_block1(x, c_emb)
+        x = self.mid_attn(x)
+        if self.conditioning_type == 'attention':
+            x = self.mid_attention(x, context=context)
+        x = self.mid_block2(x, c_emb)
+
+        for resnet, resnet2, attn_self, attn_conditioning, upsample in self.ups:
+            x = torch.cat((x, h.pop()), dim=1)
+            x = resnet(x, c_emb)
+            x = resnet2(x, c_emb)
+            x = attn_self(x)
+            if self.conditioning_type == 'attention':
+                x = attn_conditioning(x, context=context)
+            x = upsample(x)
+
+        x = self.final_conv(x)
+
+        x = einops.rearrange(x, 'b c h -> b h c')
+
+        return x
+
+
+class EnvModel(nn.Module):
+
+    def __init__(
+            self,
+            in_dim=16,
+            out_dim=16,
+            **kwargs
+    ):
+        super().__init__()
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+
+        self.net = nn.Identity()
+
+    def forward(self, input_d):
+        env = input_d['env']
+        env_emb = self.net(env)
+        return env_emb
+
+
+class TaskModel(nn.Module):
+
+    def __init__(
+            self,
+            in_dim=16,
+            out_dim=32,
+            **kwargs
+    ):
+        super().__init__()
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+
+        self.net = nn.Identity()
+
+    def forward(self, input_d):
+        task = input_d['tasks']
+        task_emb = self.net(task)
+        return task_emb
+
+
+class TaskModelNew(nn.Module):
+
+    def __init__(
+            self,
+            in_dim=16,
+            out_dim=32,
+            **kwargs
+    ):
+        super().__init__()
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+
+        self.net = nn.Identity()
+
+    def forward(self, task):
+        task_emb = self.net(task)
+        return task_emb
+
+
+class ContextModel(nn.Module):
+
+    def __init__(
+            self,
+            env_model=None,
+            task_model=None,
+            out_dim=32,
+            **kwargs
+    ):
+        super().__init__()
+
+        self.env_model = env_model
+        self.task_model = task_model
+
+        self.in_dim = self.env_model.out_dim + self.task_model.out_dim
+
+        # self.out_dim = out_dim
+        # self.net = MLP(self.in_dim, self.out_dim, hidden_dim=out_dim, n_layers=1, act='mish')
+
+        self.out_dim = self.in_dim
+        self.net = nn.Identity()
+
+    def forward(self, input_d=None):
+        if input_d is None:
+            return None
+        env_emb = self.env_model(input_d)
+        task_emb = self.task_model(input_d)
+        context = torch.cat((env_emb, task_emb), dim=-1)
+        context_emb = self.net(context)
+        return context_emb
+
+
+class PointUnet(nn.Module):
+
+    def __init__(
+            self,
+            n_support_points=None,
+            state_dim=None,
+            dim=32,
+            dim_mults=(1, 2, 4),
+            time_emb_dim=32,
+            conditioning_embed_dim=4,
+            conditioning_type=None,
+            **kwargs
+    ):
+        super().__init__()
+
+        self.dim_mults = dim_mults
+
+        self.state_dim = state_dim
+        input_dim = state_dim
+
+        # Conditioning
+        if conditioning_type is None or conditioning_type == 'None':
+            conditioning_type = None
+        elif conditioning_type == 'concatenate':
+            if self.state_dim < conditioning_embed_dim // 4:
+                # Embed the state in a latent space HxF if the conditioning embedding is much larger than the state
+                state_emb_dim = conditioning_embed_dim // 4
+                self.state_encoder = MLP(state_dim, state_emb_dim, hidden_dim=state_emb_dim//2, n_layers=1, act='mish')
+            else:
+                state_emb_dim = state_dim
+                self.state_encoder = nn.Identity()
+            input_dim = state_emb_dim + conditioning_embed_dim
+        elif conditioning_type == 'default':
+            pass
+        else:
+            raise NotImplementedError
+        self.conditioning_type = conditioning_type
+
+        dims = [input_dim, *map(lambda m: dim * m, self.dim_mults)]
+        in_out = list(zip(dims[:-1], dims[1:]))
+        print(f'[ models/temporal ] Channel dimensions: {in_out}')
+
+        # Networks
+        self.time_mlp = TimeEncoder(32, time_emb_dim)
+
+        # conditioning dimension (time + context)
+        cond_dim = time_emb_dim + (conditioning_embed_dim if conditioning_type == 'default' else 0)
+
+        # Unet
+        self.downs = nn.ModuleList([])
+        self.ups = nn.ModuleList([])
+
+        for ind, (dim_in, dim_out) in enumerate(in_out):
+            self.downs.append(nn.ModuleList([
+                TemporalBlockMLP(dim_in, dim_out, cond_dim)
+            ]))
+
+        mid_dim = dims[-1]
+        self.mid_block1 = TemporalBlockMLP(mid_dim, mid_dim, cond_dim)
+
+        for ind, (dim_in, dim_out) in enumerate(reversed(in_out[1:])):
+            self.ups.append(nn.ModuleList([
+                TemporalBlockMLP(dim_out * 2, dim_in, cond_dim)
+            ]))
+
+        self.final_layer = nn.Sequential(
+            MLP(dim, state_dim, hidden_dim=dim, n_layers=0, act='identity')
+        )
+
+    def forward(self, x, time, context):
+        """
+        x : [ batch x horizon x state_dim ]
+        context: [batch x context_dim]
+        """
+        x = einops.rearrange(x, 'b 1 d -> b d')
+
+        t_emb = self.time_mlp(time)
+        c_emb = t_emb
+        if self.conditioning_type == 'concatenate':
+            x_emb = self.state_encoder(x)
+            x = torch.cat((x_emb, context), dim=-1)
+        elif self.conditioning_type == 'default':
+            c_emb = torch.cat((t_emb, context), dim=-1)
+
+        h = []
+        for resnet, in self.downs:
+            x = resnet(x, c_emb)
+            h.append(x)
+
+        x = self.mid_block1(x, c_emb)
+
+        for resnet, in self.ups:
+            x = torch.cat((x, h.pop()), dim=1)
+            x = resnet(x, c_emb)
+
+        x = self.final_layer(x)
+
+        x = einops.rearrange(x, 'b d -> b 1 d')
+
+        return x

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/trainer/__init__.py

@@ -0,0 +1 @@
+from .trainer import train, get_num_epochs

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/trainer/trainer.py

@@ -0,0 +1,385 @@
+import copy
+from math import ceil
+
+import numpy as np
+import os
+import time
+import collections
+import torch
+import wandb
+from collections import defaultdict
+from tqdm.autonotebook import tqdm
+from cfdp.diffusion_policy.utils.utils import TimerCUDA
+
+
+#TODO: select which GPU
+DEFAULT_TENSOR_ARGS = {'device': 'cuda', 'dtype': torch.float32}
+
+def get_torch_device(device='cuda'):
+    if 'cuda' in device and torch.cuda.is_available():
+        device = 'cuda'
+    else:
+        device = 'cpu'
+    return torch.device(device)
+
+
+def dict_to_device(ob, device):
+    if isinstance(ob, (dict, collections.abc.Mapping)):
+        return {k: dict_to_device(v, device) for k, v in ob.items()}
+    else:
+        return ob.to(device)
+
+
+def to_numpy(x, dtype=np.float32, clone=False):
+    if torch.is_tensor(x):
+        x = x.detach().cpu().numpy().astype(dtype)
+        return x
+    if isinstance(x, np.ndarray):
+        return x.astype(dtype, copy=clone)
+    return np.array(x).astype(dtype)
+
+
+def get_num_epochs(num_train_steps, batch_size, dataset_len):
+    return ceil(num_train_steps * batch_size / dataset_len)
+
+
+def save_models_to_disk(models_prefix_l, epoch, total_steps, checkpoints_dir=None):
+    for model, prefix in models_prefix_l:
+        if model is not None:
+            save_model_to_disk(model, epoch, total_steps, checkpoints_dir, prefix=f'{prefix}_')
+            for submodule_key, submodule_value in model.submodules.items():
+                save_model_to_disk(submodule_value, epoch, total_steps, checkpoints_dir,
+                                   prefix=f'{prefix}_{submodule_key}_')
+
+
+def save_model_to_disk(model, epoch, total_steps, checkpoints_dir=None, prefix='model_'):
+    # If the model is frozen we do not save it again, since the parameters did not change
+    if hasattr(model, 'is_frozen') and model.is_frozen:
+        return
+
+    torch.save(model.state_dict(), os.path.join(checkpoints_dir, f'{prefix}current_state_dict.pth'))
+    torch.save(model.state_dict(), os.path.join(checkpoints_dir, f'{prefix}epoch_{epoch:04d}_iter_{total_steps:06d}_state_dict.pth'))
+    torch.save(model, os.path.join(checkpoints_dir, f'{prefix}current.pth'))
+    torch.save(model, os.path.join(checkpoints_dir, f'{prefix}epoch_{epoch:04d}_iter_{total_steps:06d}.pth'))
+
+def save_losses_to_disk(train_losses, val_losses, checkpoints_dir=None):
+    np.save(os.path.join(checkpoints_dir, f'train_losses.npy'), train_losses)
+    np.save(os.path.join(checkpoints_dir, f'val_losses.npy'), val_losses)
+
+
+class EarlyStopper:
+    # https://stackoverflow.com/questions/71998978/early-stopping-in-pytorch
+
+    def __init__(self, patience=10, min_delta=0):
+        self.patience = patience  # use -1 to deactivate it
+        self.min_delta = min_delta
+        self.counter = 0
+        self.min_validation_loss = torch.inf
+
+    def early_stop(self, validation_loss):
+        if self.patience == -1:
+            return
+        if validation_loss < self.min_validation_loss:
+            self.min_validation_loss = validation_loss
+            self.counter = 0
+        elif validation_loss > (self.min_validation_loss + self.min_delta):
+            self.counter += 1
+            if self.counter >= self.patience:
+                return True
+        return False
+
+
+class EMA:
+    """
+    https://github.com/jannerm/diffuser
+    (empirical) exponential moving average parameters
+    """
+
+    def __init__(self, beta=0.995):
+        super().__init__()
+        self.beta = beta
+
+    def update_model_average(self, ema_model, current_model):
+        for ema_params, current_params in zip(ema_model.parameters(), current_model.parameters()):
+            old_weight, up_weight = ema_params.data, current_params.data
+            ema_params.data = self.update_average(old_weight, up_weight)
+
+    def update_average(self, old, new):
+        if old is None:
+            return new
+        return old * self.beta + (1 - self.beta) * new
+
+
+def do_summary(
+        summary_fn,
+        train_steps_current,
+        model,
+        batch_dict,
+        loss_info,
+        datasubset,
+        **kwargs
+):
+    if summary_fn is None:
+        return
+
+    with torch.no_grad():
+        # set model to evaluation mode
+        model.eval()
+
+        summary_fn(train_steps_current,
+                   model,
+                   batch_dict=batch_dict,
+                   loss_info=loss_info,
+                   datasubset=datasubset,
+                   **kwargs
+                   )
+
+    # set model to training mode
+    model.train()
+
+
+def train(model=None, train_dataloader=None, epochs=None, lr=None, steps_til_summary=None, model_dir=None, loss_fn=None,
+          train_subset=None,
+          summary_fn=None, steps_til_checkpoint=None,
+          val_dataloader=None, val_subset=None,
+          clip_grad=False,
+          clip_grad_max_norm=1.0,
+          val_loss_fn=None,
+          optimizers=None, steps_per_validation=10, max_steps=None,
+          use_ema: bool = True,
+          ema_decay: float = 0.995, step_start_ema: int = 1000, update_ema_every: int = 10,
+          use_amp=False,
+          early_stopper_patience=-1,
+          debug=False,
+          tensor_args=DEFAULT_TENSOR_ARGS,
+          **kwargs
+          ):
+
+    print(f'\n------- TRAINING STARTED -------\n')
+
+    ema_model = None
+    if use_ema:
+        # Exponential moving average model
+        ema = EMA(beta=ema_decay)
+        ema_model = copy.deepcopy(model)
+
+    # Model optimizers
+    if optimizers is None:
+        optimizers = [torch.optim.Adam(lr=lr, params=model.parameters())]
+
+    # Automatic Mixed Precision
+    scaler = torch.amp.GradScaler('cuda', enabled=use_amp)
+
+    if val_dataloader is not None:
+        assert val_loss_fn is not None, "If validation set is passed, have to pass a validation loss_fn!"
+
+    ## Build saving directories
+    os.makedirs(model_dir, exist_ok=True)
+
+    summaries_dir = os.path.join(model_dir, 'summaries')
+    os.makedirs(summaries_dir, exist_ok=True)
+
+    checkpoints_dir = os.path.join(model_dir, 'checkpoints')
+    os.makedirs(checkpoints_dir, exist_ok=True)
+
+    # Early stopping
+    early_stopper = EarlyStopper(patience=early_stopper_patience, min_delta=0)
+
+    stop_training = False
+    train_steps_current = 0
+
+    # save models before training
+    save_models_to_disk([(model, 'model'), (ema_model, 'ema_model')], 0, 0, checkpoints_dir)
+
+    with tqdm(total=len(train_dataloader) * epochs, mininterval=1 if debug else 60) as pbar:
+        train_losses_l = []
+        validation_losses_l = []
+        for epoch in range(epochs):
+            model.train()  # set model to training mode
+            for step, train_batch_dict in enumerate(train_dataloader):
+                ####################################################################################################
+                # TRAINING LOSS
+                ####################################################################################################
+                with TimerCUDA() as t_training_loss:
+                    train_batch_dict = dict_to_device(train_batch_dict, tensor_args['device'])
+
+                    # Compute losses
+                    with torch.autocast(device_type='cuda', dtype=torch.float16, enabled=use_amp):
+                        train_losses, train_losses_info = loss_fn(model, train_batch_dict, train_subset.dataset)
+
+                    train_loss_batch = 0.
+                    train_losses_log = {}
+                    for loss_name, loss in train_losses.items():
+                        single_loss = loss.mean()
+                        train_loss_batch += single_loss
+                        train_losses_log[loss_name] = to_numpy(single_loss).item()
+
+                ####################################################################################################
+                # SUMMARY
+                if train_steps_current % steps_til_summary == 0:
+                    # TRAINING
+                    print(f"\n-----------------------------------------")
+                    print(f"train_steps_current: {train_steps_current}")
+                    print(f"t_training_loss: {t_training_loss.elapsed:.4f} sec")
+                    print(f"Total training loss {train_loss_batch:.4f}")
+                    print(f"Training losses {train_losses}")
+
+                    train_losses_l.append((train_steps_current, train_losses_log))
+
+                    with TimerCUDA() as t_training_summary:
+                        do_summary(
+                            summary_fn,
+                            train_steps_current,
+                            ema_model if ema_model is not None else model,
+                            train_batch_dict,
+                            train_losses_info,
+                            train_subset,
+                            prefix='TRAINING ',
+                            debug=debug,
+                            tensor_args=tensor_args
+                        )
+                    print(f"t_training_summary: {t_training_summary.elapsed:.4f} sec")
+
+                    ################################################################################################
+                    # VALIDATION LOSS and SUMMARY
+                    validation_losses_log = {}
+                    if val_dataloader is not None:
+
+                        #Remove time cuda
+                        print("Running validation...")
+                        val_losses = defaultdict(list)
+                        total_val_loss = 0.
+                        for step_val, batch_dict_val in enumerate(val_dataloader):
+                            batch_dict_val = dict_to_device(batch_dict_val, tensor_args['device'])
+                            val_loss, val_loss_info = loss_fn(
+                                model, batch_dict_val, val_subset.dataset, step=train_steps_current)
+                            for name, value in val_loss.items():
+                                single_loss = to_numpy(value)
+                                val_losses[name].append(single_loss)
+                                total_val_loss += np.mean(single_loss).item()
+
+                            if step_val == steps_per_validation:
+                                break
+
+                        validation_losses = {}
+                        for loss_name, loss in val_losses.items():
+                            single_loss = np.mean(loss).item()
+                            validation_losses[f'VALIDATION {loss_name}'] = single_loss
+                        print(f"Validation losses {validation_losses}")
+
+                        # with TimerCUDA() as t_validation_loss:
+                        #     print("Running validation...")
+                        #     val_losses = defaultdict(list)
+                        #     total_val_loss = 0.
+                        #     for step_val, batch_dict_val in enumerate(val_dataloader):
+                        #         batch_dict_val = dict_to_device(batch_dict_val, tensor_args['device'])
+                        #         val_loss, val_loss_info = loss_fn(
+                        #             model, batch_dict_val, val_subset.dataset, step=train_steps_current)
+                        #         for name, value in val_loss.items():
+                        #             single_loss = to_numpy(value)
+                        #             val_losses[name].append(single_loss)
+                        #             total_val_loss += np.mean(single_loss).item()
+
+                        #         if step_val == steps_per_validation:
+                        #             break
+
+                        #     validation_losses = {}
+                        #     for loss_name, loss in val_losses.items():
+                        #         single_loss = np.mean(loss).item()
+                        #         validation_losses[f'VALIDATION {loss_name}'] = single_loss
+                        #     print("... finished validation.")
+
+                        # print(f"t_validation_loss: {t_validation_loss.elapsed:.4f} sec")
+                        # print(f"Validation losses {validation_losses}")
+
+                        validation_losses_log = validation_losses
+                        validation_losses_l.append((train_steps_current, validation_losses_log))
+
+                        # The validation summary is done only on one batch of the validation data
+                        with TimerCUDA() as t_validation_summary:
+                            do_summary(
+                                summary_fn,
+                                train_steps_current,
+                                ema_model if ema_model is not None else model,
+                                batch_dict_val,
+                                val_loss_info,
+                                val_subset,
+                                prefix='VALIDATION ',
+                                debug=debug,
+                                tensor_args=tensor_args
+                            )
+                        print(f"t_valididation_summary: {t_validation_summary.elapsed:.4f} sec")
+
+                    wandb.log({**train_losses_log, **validation_losses_log}, step=train_steps_current)
+
+                ####################################################################################################
+                # Early stopping
+                if early_stopper.early_stop(total_val_loss):
+                    print(f'Early stopped training at {train_steps_current} steps.')
+                    stop_training = True
+
+                ####################################################################################################
+                # OPTIMIZE TRAIN LOSS BATCH
+                with TimerCUDA() as t_training_optimization:
+                    for optim in optimizers:
+                        optim.zero_grad()
+
+                    scaler.scale(train_loss_batch).backward()
+
+                    if clip_grad:
+                        for optim in optimizers:
+                            scaler.unscale_(optim)
+                        torch.nn.utils.clip_grad_norm_(
+                            model.parameters(),
+                            max_norm=clip_grad_max_norm if isinstance(clip_grad, bool) else clip_grad
+                        )
+
+                    for optim in optimizers:
+                        scaler.step(optim)
+
+                    scaler.update()
+
+                    if ema_model is not None:
+                        if train_steps_current % update_ema_every == 0:
+                            # update ema
+                            if train_steps_current < step_start_ema:
+                                # reset parameters ema
+                                ema_model.load_state_dict(model.state_dict())
+                            ema.update_model_average(ema_model, model)
+
+                if train_steps_current % steps_til_summary == 0:
+                    print(f"t_training_optimization: {t_training_optimization.elapsed:.4f} sec")
+
+                ####################################################################################################
+                # SAVING
+                ####################################################################################################
+                pbar.update(1)
+                train_steps_current += 1
+
+                if (steps_til_checkpoint is not None) and (train_steps_current % steps_til_checkpoint == 0):
+                    save_models_to_disk([(model, 'model'), (ema_model, 'ema_model')],
+                                        epoch, train_steps_current, checkpoints_dir)
+                    save_losses_to_disk(train_losses_l, validation_losses_l, checkpoints_dir)
+
+                if stop_training or (max_steps is not None and train_steps_current == max_steps):
+                    break
+
+            if max_steps is not None and train_steps_current == max_steps:
+                break
+
+        # Update ema model at the end of training
+        if ema_model is not None:
+            # update ema
+            if train_steps_current < step_start_ema:
+                # reset parameters ema
+                ema_model.load_state_dict(model.state_dict())
+            ema.update_model_average(ema_model, model)
+
+        # Save model at end of training
+        save_models_to_disk([(model, 'model'), (ema_model, 'ema_model')],
+                            epoch, train_steps_current, checkpoints_dir)
+        save_losses_to_disk(train_losses_l, validation_losses_l, checkpoints_dir)
+
+        print(f'\n------- TRAINING FINISHED -------')
+
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/diffusion_policy/utils/__init__.py

@@ -0,0 +1 @@
+from .utils import TimerCUDA