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 },