def produceFile(skeletonFile, i):
from skeleton import Skeleton
skId, scId, scFile = matches[i]
skel = Skeleton(skeletonFile[skId])
outputName = 'david2/viz/' + str(skId) + '.obj'
print outputName
f = open(outputName, 'w')
# skeleton geom
for part in jointNames:
pos = skel.GetPos(part)
if pos:
f.write('v %f %f %f 1 0 0\n' % (pos[0], pos[1], pos[2]))
else:
f.write('v nan nan nan 1 0 0\n')
for row in readPcd('david2/pcd/' + scFile, Skeleton.scale):
f.write('v %f %f %f %f %f %f\n' % row)
# skeleton connectivity
f.write("""f 1 2 3
f 1 3 4
f 1 3 5
f 3 4 6
f 4 6 8
f 3 5 7
f 5 7 9
f 3 1 10
f 3 1 11
f 10 12 14
f 11 13 15
""")
f.close()
def init(self):
pygame.init()
self.skeleton = Skeleton(self)
self._init_surface()
self.screen_lock = thread.allocate()
self._init_screen()
self._init_kinect()
def create():
if request.post_vars.site:
post = request.post_vars.site
from skeleton import Skeleton
s = Skeleton(post)
return dict()
def display_skeleton(kinect_node, idx, loader):
bodies, univ_time = loader.load_body_file(idx)
skeleton_list = [Skeleton(x) for x in bodies]
kinect_idx = loader.nearest_depth_idx(univ_time, kinect_node)
img = loader.load_depth_frame(kinect_node, kinect_idx)
cmap = plt.get_cmap('jet')
rgba = cmap(img)
rgba[:, :, 0] *= 0
for skeleton in skeleton_list:
joints = skeleton_2d_points(skeleton, loader, kinect_node)
edges = []
for limb in SkeletonLimbs:
point_a = joints[limb.value[0].value]
point_b = joints[limb.value[1].value]
edges.append(((point_a[0], point_a[1]), (point_b[0], point_b[1])))
mag_map = magnitude_map(img, edges)
rgba[:, :, 0] += mag_map
# img = np.multiply(img, mag_map)
plt.imshow(img, interpolation='nearest', cmap='jet')
plt.imshow(rgba)
plt.show()
def __init__(self, args):
rospy.init_node('roadmap_server')
self.optimization_distance = rospy.get_param('~optimization_distance', 10);
self.tf = TransformListener()
stereo_cam = camera.Camera((389.0, 389.0, 89.23 * 1e-3, 323.42, 323.42, 274.95))
self.skel = Skeleton(stereo_cam)
# self.skel.node_vdist = 1
if False:
self.skel.load(args[1])
self.skel.optimize()
self.startframe = 100000
else:
self.startframe = 0
self.frame_timestamps = {}
self.vo = None
self.pub = rospy.Publisher("roadmap", vslam.msg.Roadmap)
time.sleep(1)
#self.send_map(rospy.time(0))
self.wheel_odom_edges = set()
rospy.Subscriber('/wide_stereo/raw_stereo', stereo_msgs.msg.RawStereo, self.handle_raw_stereo, queue_size=2, buff_size=7000000)
def main():
points = list(pcd.read('david2/pcd/david2_1317518872.840330800.pcd'))
sk = Skeleton(boneData())
skBones = sk.Bones()
segments = dict((key,[]) for key in skBones.keys()) # setup
for p in points:
minDist = 1e20 # big
bestBone = 'T' # torso by default
for bName,bone in skBones.iteritems(): # for all bones
src,dst = bone
boneDir = subtract(dst, src)
offset = subtract(p, src)
dist = crossNormSqr(boneDir,offset)/dot(offset,offset)
if dist < minDist:
minDist = dist
bestBone = bName
if sqrt(minDist) < 10:
segments[bestBone].append(p)
f = open('segmented.obj', 'w')
for segName,points in segments.iteritems():
print segName, len(points)
if segName in ('LE2H', 'RE2H', 'LK2F', 'RK2F'):
color = (1,0,0)
elif segName in ('LS2E', 'RS2E', 'LH2K', 'RH2K'):
color = (0,1,0)
elif segName == 'T':
color = (0,0,1)
elif segName == 'N2H':
color = (0,1,1)
for p in points:
col = blend(p[3:], color, 0.25) # tint
f.write('v %f %f %f %f %f %f\n'%(p[0],p[1],p[2],col[0],col[1],col[2]))
def train_test_split_observations(ratio, classifier):
data_dir = Path('..') / 'z'
clips = []
# Store Path objects pointing to clipped skeletons
for root, dirs, files in os.walk(str(data_dir)):
clips += [ Path(root) / f for f in fnmatch.filter(files, '*clipped*tsv') ]
# Random split into training and test data
np.random.shuffle(clips)
split_pt = int(ratio * len(clips))
clips_train = clips[:split_pt]
clips_test = clips[split_pt:]
O = []
X = []
y = []
for c in clips_train:
s = Skeleton(str(c))
s.load(skipheader=False, delimiter='\t', extracols=(232,))
s.angularize()
X += [ s.data[:,:-1].tolist() ]
y += [ s.data[:,-1].tolist() ]
classifier.fit([frame for clip in X for frame in clip ], [ label for clip in y for label in clip ])
for clip in X:
O += [ classifier.predict(clip).tolist() ]
O_test = []
X_test = []
y_test = []
for c in clips_test:
s = Skeleton(str(c))
s.load(skipheader=False, delimiter='\t', extracols=(232,))
s.angularize()
X_test += [ s.data[:, :-1].tolist() ]
y_test += [ s.data[:, -1].tolist() ]
for clip in X_test:
O_test += [ classifier.predict(clip).tolist() ]
return (X, y, O, X_test, y_test, O_test)
def __init__(self,
data_root,
max_seq_len,
delta_len,
n_breakpoints=0,
speed_range=[1, 1],
acc_range=[-1, 1],
train=True,
remove_static_joints=True,
mode='train'):
# Set arguments
self.data_root = osp.abspath(osp.expanduser(data_root))
self.max_seq_len = max_seq_len
self.delta_len = delta_len
self.speed_range = speed_range
self.n_breakpoints = n_breakpoints
self.acc_range = acc_range
self.remove_static_joints = remove_static_joints
self.train = train
self.subseq_len = self.delta_len * 2
self.skeleton = Skeleton(
parents=[
-1, 0, 1, 2, 3, 4, 0, 6, 7, 8, 9, 0, 11, 12, 13, 14, 12, 16,
17, 18, 19, 20, 19, 22, 12, 24, 25, 26, 27, 28, 27, 30
],
joints_left=[6, 7, 8, 9, 10, 16, 17, 18, 19, 20, 21, 22, 23],
joints_right=[1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29, 30, 31])
assert mode in [
'train', 'test'
], 'Invalid mode for Human36mDataset. Must be \'train\' or \'test\'.'
self.mode = mode
# Read dataset
self.raw_data = read_human36m(self.data_root, self.mode)
# Reformat data
self.data = reformat_data(self.raw_data)
# Filter out sequence that is shorter than `max_seq_len`
self.data['pose']['3d'] = list(
filter(lambda x: x.shape[0] >= self.max_seq_len,
self.data['pose']['3d']))
self.data['pose']['2d'] = list(
filter(lambda x: x.shape[0] >= self.max_seq_len,
self.data['pose']['2d']))
# Remove static joints
if self.remove_static_joints:
# Bring the skeleton to 17 joints instead of the original 32
self.remove_joints(
[4, 5, 9, 10, 11, 16, 20, 21, 22, 23, 24, 28, 29, 30, 31])
# Rewire shoulders to the correct parents
self.skeleton._parents[11] = 8
self.skeleton._parents[14] = 8
# Preprocess data; NOTE: make sure index of pivot joint is correct, if used.
align_and_normalize_dataset_v2(self.data)
def __init__(self, id, skel_cap, depth_generator):
self.id = id
self.skeleton = Skeleton(self, skel_cap, depth_generator)
self.depth = 0
self.face = None
self.image_path = ''
self.choose_image()
def test_remote_proxy(self):
machine = GumballMachine(3, 'HZ')
skeleton = Skeleton(machine)
monitor = GumballMonitor()
stub = Stub()
monitor.set_stub(stub)
stub.set_skeleton(skeleton)
monitor.report()
def exportSkel(obj, filename):
skeleton = Skeleton()
skeleton.update(obj)
f = open(filename, 'w')
writeJoint(f, skeleton.root)
f.close()
def create_monsters(self):
monsters = []
boss = Boss()
boss.level = self.area_number
monsters.append(boss)
skeletons = []
number_of_skeletons = randrange(2, 5)
for i in range(number_of_skeletons):
skeletons.append(Skeleton('Skeleton_' + str(i + 1)))
skeletons[0].has_key = True
for skeleton in skeletons:
skeleton.level = self.area_number
monsters.append(skeleton)
return monsters
def read_csv(filename):
data = []
with open(filename, 'r') as reader:
for line in reader:
fields = line.split(',')
fields[len(fields) - 1] = fields[len(fields) - 1].replace('\n', '')
for i in range(len(fields)):
data.append(float(fields[i]))
data = np.array(data).reshape((int)(len(data) / 32 / 3), 32, 3)
skeletons = []
for d in data:
skeletons.append(Skeleton(d))
return skeletons
def __on_skeleton_changed(self, skeleton_message):
""" reacts to publishers message by updating the skeletons and
notifies listeners to create and remove objects accordingly.
Args:
skeleton_message (list): [0] skeleton_id (int) and [1] skeleton (Skeleton)
"""
if len(skeleton_message) < 2:
return
skeleton_id = skeleton_message[0]
if skeleton_message[1] is 'kill':
# remove
self.__notify_remove_skeleton(skeleton_id)
return
skeleton_joint = skeleton_message[1]
# print 'joint type: ', skeleton_joint.joint_type
# check if skeleton id is known
# if yes - update can be done, just count another change
if skeleton_id in self.__skeletons and skeleton_id in self.__skeleton_changes:
self.__skeleton_changes[skeleton_id] += 1
# if no - create skeleton so that update can be done
else:
self.__skeletons[skeleton_id] = Skeleton(skeleton_id)
self.__skeleton_changes[skeleton_id] = 1
# add or update joint
# self.__skeletons[skeleton_id].update_joint(skeleton_joint.joint_type, skeleton_joint)
self.__skeletons[skeleton_id].update_joint_smooth(
skeleton_joint.joint_type, skeleton_joint)
# if number of changes (joints) enough propagate to listeners: (create and) update objects
# if skeleton_id in self.__skeleton_changes and self.__skeleton_changes[skeleton_id] > 24:
# use update interval to react only to every Xth change of the skeleton, x = self.update_interval
if skeleton_id in self.__skeleton_changes \
and self.__skeleton_changes[skeleton_id] / 25.0 >= self.__update_interval:
self.__skeleton_changes[skeleton_id] = 0
# check if skeleton already complete and active before
if skeleton_id not in self.__active_skeletons:
self.__notify_create_skeleton(skeleton_id)
# update listeners on skeleton change
self.__notify_update_skeleton(skeleton_id)
self.__reset_lifetime(skeleton_id)
def gen_sim_matrix(x_files, y_files):
# Get a combined list of the skeleton files chosen earlier
combined_files = x_files + y_files
# Initializing the similarity matrix to be used for final comparison
s_matrix = np.zeros(len(combined_files)**2).reshape(
len(combined_files), len(combined_files))
# Populating the similarity matrix with distance outputs from DTW
for i, file_i in enumerate(combined_files):
sk_i = Skeleton(file_i)
sk_i.load()
sk_i.normalize('spine-base')
for j, file_j in enumerate(combined_files):
sk_j = Skeleton(file_j)
sk_j.load()
sk_j.normalize('spine-base')
dist, cost, acc, path = dtw(
sk_i.data, sk_j.data, dist=lambda a, b: np.linalg.norm(a - b))
s_matrix[i, j] = dist
return s_matrix
def train_test_split_clips(ratio):
data_dir = Path('..') / 'z'
clips = []
# Store Path objects pointing to clipped skeletons
for root, dirs, files in os.walk(str(data_dir)):
clips += [
Path(root) / f for f in fnmatch.filter(files, '*clipped*tsv')
]
# Random split into training and test data
np.random.shuffle(clips)
split_pt = int(ratio * len(clips))
clips_train = clips[:split_pt]
clips_test = clips[split_pt:]
X = []
y = []
for c in clips_train:
s = Skeleton(str(c))
s.load(skipheader=False, delimiter='\t', extracols=(232, ))
#s.normalize('spine-base')
X += s.data[:, :-1].tolist()
y += s.data[:, -1].tolist()
X_test = []
y_test = []
for c in clips_test:
s = Skeleton(str(c))
s.load(skipheader=False, delimiter='\t', extracols=(232, ))
X_test += s.data[:, :-1].tolist()
y_test += s.data[:, -1].tolist()
return (X, y, X_test, y_test)
def __init__(self, video_name):
self.title_window = "Demonstrateur reconnaissance de personne"
self.skeletonService = Skeleton()
self.cap = cv2.VideoCapture(video_name)
self.opWrapper = op.WrapperPython()
self.opWrapper.configure(params)
self.opWrapper.start()
self.gaitClassifier = GaitClassifier()
self.last_frame = None
self.kp_frames = []
self.stop = False
w, h = (int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
self.out = cv2.VideoWriter(
"Recording_" + datetime.datetime.now().strftime("%Y%m%d_%H%M%S") +
".mp4", cv2.VideoWriter_fourcc(*'MP4V'), 25, (w, h))
def render(filename, color, theta, dest): skel = Skeleton(stereo_cam) skel.load(filename, load_PR = False) skel.optimize() skel.optimize() skel.plot(color, False, theta) xlim = pylab.xlim() ylim = pylab.ylim() xrange = xlim[1] - xlim[0] yrange = ylim[1] - ylim[0] r = max(xrange, yrange) * 0.5 # 0.32 mid = sum(xlim) / 2 pylab.xlim(mid - r, mid + r) mid = sum(ylim) / 2 pylab.ylim(mid - r, mid + r)
def dataset_summary():
dataset_folder = io_utils.get_dataset_folder()
skinning_path = os.path.join(dataset_folder, 'skinning.npy')
skeleton_path = os.path.join(dataset_folder, 'skeleton.txt')
print('-- ANIMATION CLIPS --')
clips = fnmatch.filter(os.listdir(dataset_folder), '*.npz')
print(clips)
print('num clips : ' + str(len(clips)))
print('-- SKINNING --')
print('skinning file : ' + str(os.path.exists(skinning_path)))
print('-- SKELETON --')
print('skeleton file : ' + str(os.path.exists(skeleton_path)))
skeleton = Skeleton()
skeleton.load(skeleton_path)
skeleton.print_root()
def skeletonize(self, thres, binSize=10.0, sigma=5.0):
"""
Initialise the backbone finding routine. The "backbone" is approximated
by using a skeletonization algorithm. It will thus find a backbone with
with branches.
To find the skeleton, the localisations are binned in a 2D histogram,
blurred by a gaussian and the resulting image is binarized using the
threshold value. From the binary images pixel at the edges are taken
away until only the skeleton remains.
"""
if not self.runCluster:
print('You need to run the clustering first!')
return
self.backbone = Skeleton()
self.backbone.setData(self.cluster.getResult())
self.backbone.threshold(thres, binSize=binSize, sigma=sigma)
def init_simul(filename, test_num, cbr_num=50, div_step=1):
data = read_data_skeleton(filename)
# test_num, data = interval_compasation(data, test_num, div_step)
test_num = min(test_num, len(data))
skeletons = []
for i in range(test_num):
skeletons.append(Skeleton(data[i]))
cbr_num = min(test_num, cbr_num)
cal_skeletons = []
for i in range(cbr_num):
cal_skeletons.append(skeletons[i * div_step])
calibration = Calibration(cal_skeletons)
lower_init_mean, upper_init_mean = calibration.get_init_mean(0, filename)
return skeletons, lower_init_mean, upper_init_mean, test_num
def __param_init__(self, clean=False):
try:
self.dataset.close()
print('Save h5py ....')
if clean:
os.remove(self.kp.dstr + '.h5')
print('Remove h5py ....')
except:
pass
self.fig = None
self.kp = Kparam(self.exeno, username)
# self.movie = movie.Movie(self.exeno)
self.dtw = Dtw()
self.denoise = Denoise()
self.rel = Rel()
self.io = Dataoutput()
self.h_mod = Human_model()
self.skel = Skeleton()
self.fextr = Finger_extract()
def exportSkeleton(obj, filename):
"""
This function exports joint information describing the structure of the
MakeHuman humanoid mesh object in Biovision BVH format.
Parameters
----------
obj:
*Object3D*. The object whose information is to be used for the export.
filename:
*string*. The filename of the file to export the object to.
"""
skeleton = Skeleton()
skeleton.update(obj)
# Write bvh file
f = open(filename, 'w')
f.write('HIERARCHY\n')
f.write('ROOT ' + skeleton.root.name + '\n')
f.write('{\n')
f.write("\tOFFSET %f %f %f\n" %
(skeleton.root.position[0], skeleton.root.position[1],
skeleton.root.position[2]))
f.write(
'\tCHANNELS 6 Xposition Yposition Zposition Zrotation Xrotation Yrotation\n'
)
for joint in skeleton.root.children:
writeJoint(f, joint, 1)
f.write('}\n')
f.write('MOTION\n')
f.write('Frames: 1\n')
f.write('Frame Time: 0.0\n')
f.write(" %f %f %f" %
(skeleton.root.position[0], skeleton.root.position[1],
skeleton.root.position[2]))
for i in xrange(skeleton.endEffectors):
f.write(" 0.0000 0.0000 0.0000")
f.write("\n")
f.close()
def __proceedHuman(self, human, newSkeletons):
sameSkeletonProb = [] # probability, that human is 'i' skeleton
bb = getBoundingBox(human)
minDelta = getMinDelta(bb)
for skeleton in self.skeletons:
sameSkeletonProb.append(skeleton.compareSkeleton(human, minDelta))
if len(sameSkeletonProb) != 0:
maxProb = max(sameSkeletonProb)
else:
maxProb = 0
if maxProb >= c.probThreshold: # skeletons are the same human
i = sameSkeletonProb.index(maxProb)
self.skeletons[i].updateSkeleton(human, bb) # update skeleton
newSkeletons.append(
self.skeletons[i]) # add skeleton to new skeletons
self.skeletons.pop(i) # skeleton cannot be compared again
else:
newSkeletons.append(Skeleton(
human, self.lastSkeletonId,
bb)) # make new skeleton if there is no similar skeleton
self.lastSkeletonId = self.lastSkeletonId + 1
def _initialize_sprites(self, level_room):
for y in range(15):
for x in range(20):
cell = level_room[y][x]
normalized_x = x * self.cell_size
normalized_y = y * self.cell_size
if cell == 0:
self.floors.add(Cobble(normalized_x, normalized_y))
elif cell == 1:
self.walls.add(Brick(normalized_x, normalized_y))
elif cell == 2:
self.wizard = Wizard(normalized_x, normalized_y)
self.floors.add(Cobble(normalized_x, normalized_y))
elif cell == 3:
self.door.add(Door(normalized_x, normalized_y))
elif cell == 4:
self.floors.add(Cobble(normalized_x, normalized_y))
self.skeletons.add(Skeleton(normalized_x, normalized_y))
self.all_sprites.add(self.floors, self.walls, self.wizard, self.door, self.skeletons)
def __init__(self, source):
self.cvim = None
# These variables are internal:
self.stereo_cam = source.cam()
print "Camera is", self.stereo_cam
self.connected = False
self.snail_trail = []
self.source = source
self.inlier_history = []
self.label = 0
self.skel_dist_thresh = 0.5; # in meters
# These variables can be tweaked:
self.fd = FeatureDetectorFast(300)
# self.fd = FeatureDetectorStar(300)
self.ds = DescriptorSchemeCalonder(32,16) # set up lower sequential search window
self.camera_preview = False
self.vo = VisualOdometer(self.stereo_cam,
scavenge = False,
position_keypoint_thresh = 0.3,
angle_keypoint_thresh = 10*pi/180,
inlier_thresh = 100,
sba=None,
num_ransac_iters=500,
inlier_error_threshold = 3.0)
self.skel = Skeleton(self.stereo_cam,
link_thresh = 100,
descriptor_scheme = self.ds,
optimize_after_addition = False)
self.skel.node_vdist = 0
self.running = -1 # run forever
if self.camera_preview:
cv.NamedWindow("Camera")
cv.MoveWindow("Camera", 0, 700)
def CreateScene(pSdkManager, pScene, pSampleFileName):
lSceneInfo = KFbxDocumentInfo.Create(pSdkManager, "SceneInfo")
lSceneInfo.mTitle = "David skeleton"
lSceneInfo.mSubject = "Can we import skeleton data?"
lSceneInfo.mAuthor = "Team KinectOpenNiRosBoostGraphLibDaiPclEigen"
lSceneInfo.mRevision = "rev. 0.1"
lSceneInfo.mKeywords = "skeleton openni range scan nite"
lSceneInfo.mComment = "no particular comments required."
pScene.SetSceneInfo(lSceneInfo)
# make all skeletons
skelFile = yaml.load(open('../recordings/david2/david2_skeleton.yaml','r'))
skels = [(float(ts),Skeleton(skData)) for ts,skData in sorted(skelFile.iteritems())]
baseSkeleton = skels[0][1]
CreateSkeletonNodes(pSdkManager, "Skeleton", baseSkeleton)
AnimateSkeleton(pSdkManager, pScene, baseSkeleton, skels[1:])
pScene.GetRootNode().AddChild(baseSkeleton.torsoNode)
return True
def run_game():
# initialize the game and create a screen object using the pygame class. we create an instance screen
pygame.init()
screen = pygame.display.set_mode((1000, 600))
caption = pygame.display.set_caption("skeleton on wood race")
# set the background colour
bg_color = (255, 255, 0)
# create an instance of skeleton
skeleton = Skeleton(screen)
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit()
if event.key == pygame.K_RIGHT:
# move the skeleton to the right
skeleton.moving_right = True
if event.key == pygame.K_LEFT:
skeleton.moving_left = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
skeleton.moving_right = False
if event.key == pygame.K_LEFT:
skeleton.moving_left = False
skeleton.update()
# redraw the screen during each pass through the loop
screen.fill(bg_color)
skeleton.blitme()
# make the most recently drawn screen visible
pygame.display.flip()
def __getitem__(self, idx):
begin, end = self.videos[idx]
files = self.hand[begin:end]
skls = self.skl[begin:end]
max_seq = self.max_seq if self.max_seq is not None else len(files)
images = np.zeros((max_seq, 100, 200, 3)) - 1
skeletons = []
if self.spotting:
labels = np.array(self.labels[begin:end])
# labels = torch.from_numpy(np.where(labels > 0,1 , 0)).long()
else:
labels = torch.tensor([self.labels[begin]] * max_seq).long() - 1
for i, img_name, skl in zip(range(max_seq), files, skls):
images[i] = transform.resize(io.imread(img_name), (100, 200),
preserve_range=True).astype(np.uint8)
skeletons.append(skl)
while len(skeletons) < max_seq:
skeletons.append(Skeleton())
images = self._split_image(images)
sample = {'images': images, 'skeletons': skeletons, 'labels': labels}
if self.transform:
sample = self.transform(sample)
else:
sample['skeletons'] = torch.tensor([
skl.centralize().normalize().get_normalized_representation()
for skl in sample['skeletons']
]).float()
image = sample['images']
image = image.reshape(-1, 4, 2, self.output_size[0],
self.output_size[1], 3)
image = np.transpose(image, (0, 2, 5, 1, 3, 4)).astype(np.float32)
sample['images'] = torch.from_numpy(image)
# sample['skeletons'] = torch.tensor([skl.centralize().normalize().vectorize_reduced() for skl in sample['skeletons']]).float()
# sample['images'] = torch.from_numpy(sample['images']).float()/255.0,
return sample
import numpy as np
import copy
from skeleton import Skeleton
from mocap_dataset import MocapDataset
from camera import normalize_screen_coordinates, image_coordinates
h36m_skeleton = Skeleton(
parents=[
-1, 0, 1, 2, 3, 4, 0, 6, 7, 8, 9, 0, 11, 12, 13, 14, 12, 16, 17, 18,
19, 20, 19, 22, 12, 24, 25, 26, 27, 28, 27, 30
],
joints_left=[6, 7, 8, 9, 10, 16, 17, 18, 19, 20, 21, 22, 23],
joints_right=[1, 2, 3, 4, 5, 24, 25, 26, 27, 28, 29, 30, 31])
h36m_cameras_intrinsic_params = [
{
'id':
'54138969',
'center': [512.54150390625, 515.4514770507812],
'focal_length': [1145.0494384765625, 1143.7811279296875],
'radial_distortion':
[-0.20709891617298126, 0.24777518212795258, -0.0030751503072679043],
'tangential_distortion':
[-0.0009756988729350269, -0.00142447161488235],
'res_w':
1000,
'res_h':
1002,
'azimuth':
70, # Only used for visualization
},
