class RECORDER: numberOfGestures = 1000 gestureIndex = 0 def __init__(self): self.controller = Leap.Controller() self.pygameWindow = PYGAME_WINDOW() self.x = 250 self.y = 250 self.xMin = -100.0 self.xMax = 100.0 self.yMin = -100.0 self.yMax = 100.0 self.previousNumberOfHands = 0 self.currentNumberOfHands = 0 self.gestureData = np.zeros((5, 4, 6, self.numberOfGestures), dtype='f') self.Update_Gesture_Data() pass def Run_Forever(self): while True: self.Run_Once() self.previousNumberOfHands = self.currentNumberOfHands def Run_Once(self): self.pygameWindow.Prepare() frame = self.controller.frame() self.currentNumberOfHands = len(frame.hands) if (self.currentNumberOfHands > 0): self.Handle_Frame(frame) # pygameX = ScaleCoordinates(x, xMin, xMax, 0, constants.pygameWindowWidth) # pygameY = ScaleCoordinates(y, yMin, yMax, 0, constants.pygameWindowDepth) # pygameWindow.Draw_Black_Circle(pygameX,(constants.pygameWindowDepth - pygameY)) self.pygameWindow.Reveal() def Handle_Vector_From_Leap(self, v): x = self.ScaleCoordinates(int(v[0]), self.xMin, self.xMax, 0, constants.pygameWindowWidth) y = self.ScaleCoordinates(int(v[2]), self.yMin, self.yMax, 0, constants.pygameWindowDepth) if (x < self.xMin): self.xMin = x if (x > self.xMax): self.xMax = x if (y < self.yMin): self.yMin = y if (y > self.yMax): self.yMax = y return x, y def Handle_Bone(self, bone, finger): base = bone.prev_joint tip = bone.next_joint baseX, baseY = self.Handle_Vector_From_Leap(base) tipX, tipY = self.Handle_Vector_From_Leap(tip) color = (0, 0, 0) if (self.currentNumberOfHands == 1): color = (0, 255, 0) elif (self.currentNumberOfHands == 2): color = (255, 0, 0) self.pygameWindow.Draw_Line(color, baseX, baseY, tipX, tipY, 3 - bone.type) if self.currentNumberOfHands == 2: self.gestureData[finger, bone.type, 0, self.gestureIndex] = base[0] self.gestureData[finger, bone.type, 1, self.gestureIndex] = base[1] self.gestureData[finger, bone.type, 2, self.gestureIndex] = base[2] self.gestureData[finger, bone.type, 3, self.gestureIndex] = tip[0] self.gestureData[finger, bone.type, 4, self.gestureIndex] = tip[1] self.gestureData[finger, bone.type, 5, self.gestureIndex] = tip[2] def Handle_Finger(self, finger): for b in range(0, 4): self.Handle_Bone(finger.bone(b), finger.type) def Handle_Frame(self, frame): global x, y, xMin, xMax, yMin, yMax hand = frame.hands[0] fingers = hand.fingers for finger in fingers: self.Handle_Finger(finger) if self.currentNumberOfHands == 2: print('gesture ' + str(self.gestureIndex) + ' stored.') self.gestureIndex = self.gestureIndex + 1 if self.gestureIndex == self.numberOfGestures: # print(self.gestureData[:,:,:,99]) self.Save_Gesture() exit(0) pass def ScaleCoordinates(self, value, rangeOneLow, rangeOneHigh, rangeTwoLow, rangeTwoHigh): rangeOne = abs(rangeOneHigh - rangeOneLow) if (rangeOne == 0): return rangeTwoLow else: rangeTwo = abs(rangeTwoHigh - rangeTwoLow) return int((((value - rangeOneLow) * rangeTwo) / rangeOne) + rangeTwoLow) def Recording_Is_Ending(self): if (self.currentNumberOfHands == 1 and self.previousNumberOfHands == 2): return True return False def Save_Gesture(self): file = open("./userData/gesture.p", "wb") pickle.dump(self.gestureData, file) file.close() pass def Update_Gesture_Data(self): shutil.rmtree("./userData/") os.mkdir("./userData/")
class READER: def __init__(self): self.pygameWindow = PYGAME_WINDOW() self.numGestures = 0 self.Get_Num_Files() def Get_Num_Files(self): path, dirs, files = next(os.walk('userData')) self.numGestures = len(files) def Draw_Gestures(self): while True: self.Draw_Each_Gesture_Once() def Draw_Each_Gesture_Once(self): for i in range(0, self.numGestures): pickle_in = open("userData/gesture" + str(i) + ".p", "rb") gestureData = pickle.load(pickle_in) self.Draw_Gesture(i, gestureData) def Draw_Gesture(self, gesture_num, gestureData): self.pygameWindow.Prepare() for i in range(0, 5): for j in range(0, 4): currentBone = [] currentBone.append(gestureData[i, j, 0]) currentBone.append(gestureData[i, j, 1]) currentBone.append(gestureData[i, j, 2]) currentBone.append(gestureData[i, j, 3]) currentBone.append(gestureData[i, j, 4]) currentBone.append(gestureData[i, j, 5]) xBaseNotYetScaled = currentBone[0] yBaseNotYetScaled = currentBone[2] xTipNotYetScaled = currentBone[3] yTipNotYetScaled = currentBone[5] xBase = self.Scale(xBaseNotYetScaled, constants.min, constants.max, 0, constants.pygameWindowWidth) yBase = self.Scale(yBaseNotYetScaled, constants.min, constants.max, 0, constants.pygameWindowDepth) xTip = self.Scale(xTipNotYetScaled, constants.min, constants.max, 0, constants.pygameWindowWidth) yTip = self.Scale(yTipNotYetScaled, constants.min, constants.max, 0, constants.pygameWindowDepth) self.pygameWindow.Draw_Line(xBase, yBase, xTip, yTip, 1, (0, 0, 255)) self.pygameWindow.Reveal() time.sleep(0.75) def Scale(self, var, min1, max1, min2, max2): range1 = max1 - min1 range2 = max2 - min2 if (max1 == min1): scaled_value = float(range2) / 2 + min2 else: scaled_value = ((float(var - min1) / range1) * range2) + min2 return scaled_value
xScaledMin = 0 xScaledMax = 800 yScaledMin = 0 yScaledMax = 650 def Scale(value, rawMin, rawMax, scaledMin, scaledMax): rawFromLeft = value - rawMin ratio = float(float(rawFromLeft) / float(-rawMin + rawMax)) scaledValue = int(ratio * scaledMax) return scaledValue Delete_And_Replace() controller = Leap.Controller() while True: pygameWindow.Prepare() frame = controller.frame() handlist = frame.hands for hand in handlist: if (str(hand) > 0): Handle_Frame(frame) Recording_Is_Ending() previousNumberOfHands = currentNumberOfHands pygameWindow.Reveal()
class RECORDER: def __init__(self): self.numberOfGestures = 1000 self.gestureIndex = 0 self.gestureData = np.zeros((5, 4, 6, self.numberOfGestures), dtype='f') self.xMin = 1000.0 self.xMax = -1000.0 self.yMin = 1000.0 self.yMax = -1000.0 self.x = constants.pygameWindowWidth / 2 self.y = constants.pygameWindowDepth / 2 self.pygameWindow = PYGAME_WINDOW() self.controller = Leap.Controller() self.previousNumberOfHands = 0 self.currentNumberOfHands = 0 self.Delete_Data() def Scale_coordinate(self, var, new_min, new_max, old_min, old_max): if old_min == old_max: return new_max / 2 else: return new_min + (var - old_min) * (new_max - new_min) / (old_max - old_min) def Handle_Vector_From_Leap(self, v): self.x = int(v[0]) self.y = int(v[2]) if (self.x < self.xMin): self.xMin = self.x if (self.x > self.xMax): self.xMax = self.x if (self.y < self.yMin): self.yMin = self.y if (self.y > self.yMax): self.yMax = self.y self.x = self.Scale_coordinate(self.x, 0, constants.pygameWindowWidth, self.xMin, self.xMax) self.y = self.Scale_coordinate(self.y, 0, constants.pygameWindowDepth, self.yMin, self.yMax) return self.x, self.y def Handle_Bone(self, bone, b, frame, fingerIndex): base = bone.prev_joint tip = bone.next_joint x_base, y_base = self.Handle_Vector_From_Leap(base) x_tip, y_tip = self.Handle_Vector_From_Leap(tip) if self.currentNumberOfHands == 1: color = (0, 255, 0) else: color = (255, 0, 0) self.pygameWindow.Draw_Line(x_base, y_base, x_tip, y_tip, 5 - b, color) hand = frame.hands[0] fingers = hand.fingers j = b i = fingerIndex if self.currentNumberOfHands == 2: self.gestureData[i, j, 0, self.gestureIndex] = base[0] self.gestureData[i, j, 1, self.gestureIndex] = base[2] self.gestureData[i, j, 2, self.gestureIndex] = base[1] self.gestureData[i, j, 3, self.gestureIndex] = tip[0] self.gestureData[i, j, 4, self.gestureIndex] = tip[2] self.gestureData[i, j, 5, self.gestureIndex] = tip[1] def Handle_Finger(self, finger, frame, fingerIndex): for b in range(0, 4): self.Handle_Bone(finger.bone(b), b, frame, fingerIndex) def Handle_Frame(self, frame): fingerList = [] hand = frame.hands[0] fingers = hand.fingers j = 0 for finger in fingers: fingerList.append(finger) self.Handle_Finger(finger, frame, j) j = j + 1 if self.currentNumberOfHands == 2: print('gesture ' + str(self.gestureIndex) + ' stored.') self.gestureIndex = self.gestureIndex + 1 if self.gestureIndex == self.numberOfGestures: self.Save_Gesture() exit(0) def Run_Once(self): self.pygameWindow.Prepare() frame = self.controller.frame() self.currentNumberOfHands = len(frame.hands) if (len(frame.hands) > 0): self.Handle_Frame(frame) self.pygameWindow.Reveal() self.previousNumberOfHands = self.currentNumberOfHands def Run_Forever(self): while True: self.Run_Once() def Recording_Is_Ending(self): if self.currentNumberOfHands == 1 and self.previousNumberOfHands == 2: return True else: return False def Save_Gesture(self): pickle_out = open("userData/gesture.p", 'wb') pickle.dump(self.gestureData, pickle_out) pickle_out.close() def Delete_Data(self): shutil.rmtree('userData') os.mkdir('userData')
class DELIVERABLE: def __init__(self): self.Clear_Directory() self.controller = Leap.Controller() self.x = 500 self.y = 400 self.xMin = 1000.0 self.xMax = -1000.0 self.yMin = 1000.0 self.yMax = -1000.0 self.previousNumberOfHands = 0 self.currentNumberOfHands = 0 self.gestureData = np.zeros((5, 4, 6), dtype='f') self.numGestures = 0 self.pygameWindow = PYGAME_WINDOW() def Clear_Directory(self): shutil.rmtree("userData") os.mkdir("userData") def Scale(self, x, oldMin, oldMax, newMin, newMax): if oldMin == oldMax: newX = float(newMax - newMin) / 2 else: newX = float(newMin) + float(newMax - newMin) * float( x - oldMin) / float(oldMax - oldMin) return newX def Save_Gesture(self): pickleOut = open("userData/gesture" + str(self.numGestures) + ".p", "wb") pickle.dump(self.gestureData, pickleOut) pickleOut.close() self.numGestures += 1 def Handle_Vector_From_Leap(self, v): global xMin, xMax, yMin, yMax vX = int(v[0]) vY = -int(v[2]) if vX < self.xMin: self.xMin = vX elif vX > self.xMax: self.xMax = vX if vY < self.yMin: self.yMin = vY elif vY > self.yMax: self.yMax = vY pygameX = self.Scale(vX, self.xMin, self.xMax, 0, pygameWindowWidth) pygameY = self.Scale(vY, self.yMin, self.yMax, pygameWindowDepth, 0) return (pygameX, pygameY) def Handle_Bone(self, bone, i, j): base = bone.prev_joint tip = bone.next_joint if self.Recording_Is_Ending(): self.gestureData[i, j, 0] = bone.prev_joint[0] self.gestureData[i, j, 1] = bone.prev_joint[1] self.gestureData[i, j, 2] = bone.prev_joint[2] self.gestureData[i, j, 3] = bone.next_joint[0] self.gestureData[i, j, 4] = bone.next_joint[1] self.gestureData[i, j, 5] = bone.next_joint[2] baseCoords = self.Handle_Vector_From_Leap(base) tipCoords = self.Handle_Vector_From_Leap(tip) if self.currentNumberOfHands == 1: self.pygameWindow.Draw_Line(baseCoords, tipCoords, 4 - j, "green") else: self.pygameWindow.Draw_Line(baseCoords, tipCoords, 4 - j, "red") def Handle_Finger(self, finger, i): for j in range(0, 4): self.Handle_Bone(finger.bone(j), i, j) def Handle_Frame(self, frame): global x, y, xMin, xMax, yMin, yMax hand = frame.hands[0] fingers = hand.fingers for i in range(0, 5): self.Handle_Finger(fingers[i], i) if self.Recording_Is_Ending(): print(self.gestureData) self.Save_Gesture() def Recording_Is_Ending(self): if self.currentNumberOfHands == 1 and self.previousNumberOfHands == 2: return True def Run_Once(self): self.pygameWindow.Prepare() frame = self.controller.frame() if len(frame.hands) > 0: self.Handle_Frame(frame) self.previousNumberOfHands = self.currentNumberOfHands self.currentNumberOfHands = len(frame.hands) self.pygameWindow.Reveal() def Run_Forever(self): while True: self.Run_Once()
class DELIVERABLE: def __init__(self): self.pygameWindow = PYGAME_WINDOW() self.x = 300 self.y = 300 self.xMin = 1000.0 self.xMax = -1000.0 self.yMin = 1000.0 self.yMax = -1000.0 self.controller = Leap.Controller() self.previousNumberOfHands = 0 self.currentNumberOfHands = 0 self.gesturedata = np.zeros((5, 4, 6), dtype='f') self.gesturenumber = 0 self.Clear_Data() def Scale(self, var, min1, max1, min2, max2): range1 = max1 - min1 range2 = max2 - min2 if (max1 == min1): scaled_value = float(range2) / 2 + min2 else: scaled_value = ((float(var - min1) / range1) * range2) + min2 return scaled_value def Handle_Frame(self, frame): hand = frame.hands[0] fingers = hand.fingers for finger in fingers: self.Handle_Finger(finger) indexFingerList = fingers.finger_type(Finger.TYPE_INDEX) indexFinger = indexFingerList[0] distalPhalanx = indexFinger.bone(Bone.TYPE_DISTAL) tip = distalPhalanx.next_joint x = int(tip[0]) y = int(tip[1]) if (x < self.xMin): self.xMin = x if (x > self.xMax): self.xMax = x if (y < self.yMin): self.yMin = y if (y > self.yMax): self.yMax = y if self.Recording_Is_Ending(): print(self.gesturedata) self.Save_Gesture() def Handle_Finger(self, finger): for b in range(0, 4): self.Handle_Bone(finger.bone(b), finger) def Handle_Bone(self, bone, finger): base = bone.prev_joint tip = bone.next_joint base_x, base_y = self.Handle_Vector_From_Leap(base) tip_x, tip_y = self.Handle_Vector_From_Leap(tip) if self.currentNumberOfHands == 1: self.pygameWindow.Draw_Line(base_x, base_y, tip_x, tip_y, 3 - bone.type, (0, 255, 0)) if self.currentNumberOfHands == 2: self.pygameWindow.Draw_Line(base_x, base_y, tip_x, tip_y, 3 - bone.type, (255, 0, 0)) if (self.Recording_Is_Ending()): self.gesturedata[finger.type, bone.type, 0] = base[0] self.gesturedata[finger.type, bone.type, 1] = base[1] self.gesturedata[finger.type, bone.type, 2] = base[2] self.gesturedata[finger.type, bone.type, 3] = tip[0] self.gesturedata[finger.type, bone.type, 4] = tip[1] self.gesturedata[finger.type, bone.type, 5] = tip[2] def Handle_Vector_From_Leap(self, v): x = self.Scale(v[0], self.xMin, self.xMax, 0, constants.pygameWindowWidth) y = self.Scale(v[2], self.yMin, self.yMax, 0, constants.pygameWindowDepth) return x, y def Run_Forever(self): while True: self.Run_Once() def Run_Once(self): self.pygameWindow.Prepare() self.frame = self.controller.frame() self.currentNumberOfHands = len(self.frame.hands) if (len(self.frame.hands) > 0): self.Handle_Frame(self.frame) self.pygameWindow.Reveal() self.previousNumberOfHands = self.currentNumberOfHands def Recording_Is_Ending(self): if (self.currentNumberOfHands == 1 and self.previousNumberOfHands == 2): return True else: return False def Save_Gesture(self): pickle_out = open("userData/gesture" + str(self.gesturenumber) + ".p", "wb") pickle.dump(self.gesturedata, pickle_out) pickle_out.close() self.gesturenumber = self.gesturenumber + 1 def Clear_Data(self): shutil.rmtree("userData") os.mkdir("userData")
class Capture_Hands: def __init__(self): self.numberOfGestures = 1000 self.gestureIndex = 0 self.controller = Leap.Controller() self.pyWindow = PYGAME_WINDOW() self.xMin = 10000.0 self.xMax = -10000.0 self.yMin = 10000.0 self.yMax = -10000.0 self.previousNumberOfHands = 0 self.currentNumberOfHands = 0 self.Recording = False self.waiting2record = False self.record_counter = 0 self.gestureData = np.zeros((5, 4, 6, self.numberOfGestures), dtype='float32') def Scale(self, var_to_scale, r1, r2, r3, r4): if r1 == r2: scaled_value = int((r1 + r2) / 2) else: old_range = r2 - r1 new_range = r4 - r3 scaled_value = (((var_to_scale - r1) * new_range) / old_range) + r3 return (int(scaled_value)) def Handle_Frame(self, frame): hand = frame.hands[0] fingers = hand.fingers self.Recording_Is_Ending() for f in range(len(fingers)): self.Handle_Finger(fingers[f], f) if self.currentNumberOfHands == 2: #self.waiting2record == False and self.Recording == True: #self.Save_Gesture() self.gestureIndex += 1 if self.gestureIndex == self.numberOfGestures: self.Save_Gesture() #print(self.gestureIndex) #print(self.gestureData[:,:,:,0]) print(self.gestureData[:, :, :, 99]) exit(0) def Handle_Finger(self, finger, f_index): for bone_type in range(4): bone = self.Handle_Bone(finger, bone_type, f_index) def Handle_Bone(self, finger, bone_type, f_index): bone = finger.bone(bone_type) base = bone.prev_joint base_x, base_y, base_z, b_x, b_y, b_z = self.Handle_Vector_From_Leap( base) tip = bone.next_joint tip_x, tip_y, tip_z, t_x, t_y, t_z = self.Handle_Vector_From_Leap(tip) if self.currentNumberOfHands == 2: #self.waiting2record == False and self.Recording == True: self.gestureData[f_index, bone_type, :, self.gestureIndex] = [ b_x, b_y, b_z, t_x, t_y, t_z ] if self.currentNumberOfHands == 1: color = 'green' elif self.currentNumberOfHands == 2: color = 'red' self.pyWindow.Draw_Line(base_x, base_y, tip_x, tip_y, bone_type, color) return (bone) def Handle_Vector_From_Leap(self, vector): self.x = int(vector[0] * -1.0) self.y = int(vector[2]) self.z = int(vector[1]) if self.x < self.xMin: self.xMin = self.x if self.x > self.xMax: self.xMax = self.x if self.y < self.yMin: self.yMin = self.y if self.y > self.yMax: self.yMax = self.y unscaled_x = self.x unscaled_y = self.y unscaled_z = self.z self.x = self.Scale(self.x, self.xMax, self.xMin, 0, constants.windowWidth) self.y = self.Scale(self.y, self.yMax, self.yMin, constants.windowWidth, 0) return (self.x, self.y, self.z, unscaled_x, unscaled_y, unscaled_z) def Recording_Is_Ending(self): if self.currentNumberOfHands == 1 and self.previousNumberOfHands == 2: self.waiting2record = False self.Recording = True else: self.waiting2record = True self.Recording = False def Save_Gesture(self): Pickler(self.gestureData, "userData/gesture") #{0}".format(self.record_counter)) self.record_counter += 1 def Run_Forever(self): running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False pygame.event.get() self.pyWindow.Prepare() frame = self.controller.frame() handlist = frame.hands if (len(handlist) > 0): self.previousNumberOfHands = self.currentNumberOfHands self.currentNumberOfHands = len(handlist) self.Handle_Frame(frame) else: self.previousNumberOfHands = self.currentNumberOfHands self.currentNumberOfHands = 0 self.pyWindow.Reveal() pygame.quit()
class READER: def __init__(self): self.numGestures = 0 self.pygameWindow = PYGAME_WINDOW() self.controller = Leap.Controller() self.xRawMin = -130 self.xRawMax = 324 self.yRawMin = 350 self.yRawMax = 20 self.xScaledMin = 0 self.xScaledMax = 800 self.yScaledMin = 0 self.yScaledMax = 650 ##pygame.init() ## def Print_File(self): ## pickle_in = open(self.file, "rb") ## gestureData = pickle.load(pickle_in) ## print(gestureData) def Count_Gestures(self): path, dirs, files = next(os.walk('userData')) self.numGestures = len(files) def Print_Gestures(self): for i in range(self.numGestures): currentGestureFile = ("userData/gesture%s.p" % str(i)) pickle_in = open(currentGestureFile, "rb") currentGestureData = pickle.load(pickle_in) # print(currentGestureData) def Draw_Each_Gesture_Once(self): for i in range(self.numGestures): self.pygameWindow.Prepare() self.Draw_Gesture(i) self.pygameWindow.Reveal() time.sleep(0.8) def Draw_Gesture(self, index): currentGestureFile = ("userData/gesture%s.p" % str(index)) pickle_in = open(currentGestureFile, "rb") currentGestureData = pickle.load(pickle_in) for i in range(0, 5): for j in range(0, 4): currentBone = currentGestureData[i][j] xBaseNotYetScaled = currentBone[0] yBaseNotYetScaled = currentBone[1] xTipNotYetScaled = currentBone[3] yTipNotYetScaled = currentBone[4] #bone = finger.bone(b) #base = bone.prev_joint #tip = bone.next_joint #xBase, yBase = Handle_Vector_From_Leap(base) #xTip, yTip = Handle_Vector_From_Leap(tip) #pygameWindow.Draw_Line(xBase, yBase, xTip, yTip, b, color) xBase = self.Scale(xBaseNotYetScaled, self.xRawMin, self.xRawMax, self.xScaledMin, self.xScaledMax) yBase = self.Scale(yBaseNotYetScaled, self.yRawMin, self.yRawMax, self.yScaledMin, self.yScaledMax) xTip = self.Scale(xTipNotYetScaled, self.xRawMin, self.xRawMax, self.xScaledMin, self.xScaledMax) yTip = self.Scale(yTipNotYetScaled, self.yRawMin, self.yRawMax, self.yScaledMin, self.yScaledMax) self.pygameWindow.Draw_Line(xBase, yBase, xTip, yTip, 2, (0, 0, 255)) def Scale(self, value, rawMin, rawMax, scaledMin, scaledMax): rawFromLeft = value - rawMin ratio = float(float(rawFromLeft) / float(-rawMin + rawMax)) scaledValue = int(ratio * scaledMax) return scaledValue def Draw_Gestures(self): while True: #self.pygameWindow.Prepare() self.Draw_Each_Gesture_Once() #self.pygameWindow.Reveal() def Prepare(self): pygame.event.get() self.pygameWindow.fill((255, 255, 255)) def Reveal(self): pygame.display.update()
class DELIVERABLE: def __init__(self): self.controller = Leap.Controller() self.pygameWindow = PYGAME_WINDOW() self.x = constants.pygameWindowWidth / 2 self.y = constants.pygameWindowDepth / 2 self.xMin, self.xMax, self.yMin, self.yMax = (0, 0, 0, 0) self.stretching = False self.previousNumberOfHands = 0 self.currentNumberOfHands = 0 self.gestureData = np.zeros((5, 4, 6), dtype='f') self.pickleFileIndex = 0 self.Delete_All_UserData() def Delete_All_UserData(self): shutil.rmtree( os.path.dirname(os.path.realpath(__file__)) + "/userData") os.mkdir(os.path.dirname(os.path.realpath(__file__)) + "/userData") def Handle_Finger(self, finger): for b in range(4): bone = finger.bone(b) self.Handle_Bone(bone, finger.type, b) def Handle_Bone(self, bone, i, j): base = bone.prev_joint tip = bone.next_joint if (self.currentNumberOfHands == 1): color = 0, 255, 0 elif (self.currentNumberOfHands == 2): color = 255, 0, 0 else: color = 0, 0, 255 self.pygameWindow.Draw_Line(self.Handle_Vector_From_Leap(base), \ self.Handle_Vector_From_Leap(tip), 4-bone.type, color) # store all data if self.Recording_is_Ending(): self.gestureData[i, j, 0] = base.x self.gestureData[i, j, 1] = base.y self.gestureData[i, j, 2] = base.z self.gestureData[i, j, 3] = tip.x self.gestureData[i, j, 4] = tip.y self.gestureData[i, j, 5] = tip.z def Handle_Vector_From_Leap(self, v): global xMin, xMax, yMin, yMax global stretching x = v.x y = v.z if (x < self.xMin): self.xMin = x self.stretching = True if (x > self.xMax): self.xMax = x self.stretching = True if (y < self.yMin): self.yMin = y self.stretching = True if (y > self.yMax): self.yMax = y self.stretching = True x = self.Scale(x, self.xMin, self.xMax, 0, constants.pygameWindowWidth) y = self.Scale(y, self.yMin, self.yMax, 0, constants.pygameWindowDepth) return (x, y) def Handle_Frame(self, frame): # because the device is unstable, so sometimes it will tell you there are two hands, and next second it will tell you there's only one. # That's why the live demo in class is not doing very well. self.currentNumberOfHands = len(frame.hands) hand = frame.hands[0] fingers = hand.fingers for finger in fingers: self.Handle_Finger(finger) if self.Recording_is_Ending(): self.Save_Gesture() def Save_Gesture(self): pickle_out = open("userData/gesture%d.p" % self.pickleFileIndex, "wb") pickle.dump(self.gestureData, pickle_out) pickle_out.close() self.pickleFileIndex += 1 def Scale(self, value, sourceMin, sourceMax, targetMin, targetMax): sourceWidth = sourceMax - sourceMin if sourceWidth == 0: sourceWidth = 1 targetWidth = targetMax - targetMin sourceOffset = value - sourceMin return sourceOffset * targetWidth / sourceWidth + targetMin def Recording_is_Ending(self): return (self.previousNumberOfHands == 2 and self.currentNumberOfHands == 1) def Run_Once(self): self.pygameWindow.Prepare() self.stretching = False frame = self.controller.frame() if (len(frame.hands) > 0): self.Handle_Frame(frame) self.pygameWindow.Reveal() def Run_Forever(self): while (True): self.Run_Once() self.previousNumberOfHands = self.currentNumberOfHands
class DELIVERABLE: def __init__(self): self.xMin = 1000 self.xMax = -1000 self.yMin = 1000 self.yMax = -1000 self.x = 0 self.y = 0 self.pygameWindow = PYGAME_WINDOW() self.prevNumberOfHands = 0 self.currNumberOfHands = 0 self.gestureData = np.zeros((5, 4, 6), dtype='f') self.fileIndex = 0 self.Recreate_userData_Directory() def Recreate_userData_Directory(self): path = os.getcwd() + "\\userData\\" os.rmdir(path) os.mkdir(path) def Scale(self, a, deviceMin, deviceMax, pyMin, pyMax): # This formula is used to scale the dot from the devices coordinates # to the pygame window coordinates if deviceMin != deviceMax: deviceLength = abs(deviceMax - deviceMin) pygLength = abs(pyMax - pyMin) device_a_Location = abs(deviceMin - a) pyg_a_Location = (pygLength * device_a_Location) / deviceLength return pyg_a_Location else: return abs(pyMax - pyMin) / 2 def Handle_Vector_From_Leap(self, v): self.x = int(v[0]) self.y = int(v[2]) if (self.x < self.xMin): self.xMin = self.x if (self.x > self.xMax): self.xMax = self.x if (self.y < self.yMin): self.yMin = self.y if (self.y > self.yMax): self.yMax = self.y self.x = self.Scale(self.x, self.xMin, self.xMax, 0, self.pygameWindow.pygWindowWidth) self.y = self.Scale(self.y, self.yMin, self.yMax, 0, self.pygameWindow.pygWindowDepth) return (self.x, self.y) def Handle_Bone(self, bone, drawingWidth, i, j): base = bone.prev_joint tip = bone.next_joint if self.Recording_Is_Ending(): self.gestureData[i, j, 0] = base[0] self.gestureData[i, j, 1] = base[1] self.gestureData[i, j, 2] = base[2] self.gestureData[i, j, 3] = tip[0] self.gestureData[i, j, 4] = tip[1] self.gestureData[i, j, 5] = tip[2] (baseX, baseY) = self.Handle_Vector_From_Leap(base) (tipX, tipY) = self.Handle_Vector_From_Leap(tip) r = 0 g = 255 b = 0 if (self.currNumberOfHands == 2): r = 255 g = 0 b = 0 PYGAME_WINDOW.Draw_Line(self.pygameWindow, baseX, baseY, tipX, tipY, drawingWidth, r, g, b) def Handle_Finger(self, finger, i): for j in range(4): dWidth = 0 if (j == 0): dWidth = 4 elif (j == 1): dWidth = 3 elif (j == 2): dWidth = 2 elif (j == 3): dWidth = 1 self.Handle_Bone(finger.bone(j), dWidth, i, j) def Handle_Frame(self, frame): hand = frame.hands[0] fingers = hand.fingers for i in range(5): self.Handle_Finger(fingers[i], i) if self.Recording_Is_Ending(): self.Save_Gesture() def Save_Gesture(self): file_string = "userData/gesture" + str(self.fileIndex) + ".p" self.fileIndex += 1 pickle_out = open(file_string, "wb") pickle.dump(self.gestureData, pickle_out) pickle_out.close() def Recording_Is_Ending(self): if (self.currNumberOfHands == 1 and self.prevNumberOfHands == 2): return True def Run_Once(self): self.pygameWindow.Prepare() frame = controller.frame() if len(frame.hands) == 1: self.currNumberOfHands = 1 elif len(frame.hands) == 2: self.currNumberOfHands = 2 else: self.currNumberOfHands = 0 if (len(frame.hands) > 0): self.Handle_Frame(frame) self.pygameWindow.Reveal() if len(frame.hands) == 1: self.prevNumberOfHands = 1 elif len(frame.hands) == 2: self.prevNumberOfHands = 2 else: self.prevNumberOfHands = 0 def Run_Forever(self): while True: self.Run_Once()
class DELIVERABLE: def __init__ (self): self.xMin=500 self.xMax=-500 self.yMin=500 self.yMax=-500 self.x=250 self.y=250 self.controller= Leap.Controller() self.pygameWindow=PYGAME_WINDOW() self.previousNumberOfHands=0 self.currentNumberOfHands=0 self.gestureData = np.zeros((5,4,6),dtype='f') self.fileIndex = 0 self.Recreate_userData_Directory() def Recording_Is_Ending(self): if self.currentNumberOfHands==1: return True elif self.currentNumberOfHands==1: return False def Handle_Frame(self,frame): self.currentNumberOfHands =len(frame.hands) hand = frame.hands[0] fingers = hand.fingers for finger in fingers: self.Handle_Finger(finger) if self.Recording_Is_Ending(): #print('recording is ending.') #print(self.gestureData[0,:,:]) print(self.gestureData[0,3,3:6]) def Handle_Finger(self,finger): for b in range(4): self.Handle_Bone(b,finger) def Handle_Bone(self,b,finger): bone = finger.bone(b) base = bone.prev_joint tip = bone.next_joint if self.Recording_Is_Ending(): self.gestureData[i,j,0] = base[0] self.gestureData[i,j,1] = base[1] self.gestureData[i,j,2] = base[2] self.gestureData[i,j,3] = tip[0] self.gestureData[i,j,4] = tip[1] self.gestureData[i,j,5] = tip[2] [base_x,base_y] = self.Handle_Vector_From_Leap(base) [tip_x,tip_y] = self.Handle_Vector_From_Leap(tip) r=0 g=0 b=0 if(self.currNumberOfHands == 2): r = 255 g = 0 b = 0 self.pygameWindow.Draw_Line(color,base_x,base_y,tip_x,tip_y,r,g,b) def Handle_Vector_From_Leap(self,v): self.x = int(v[0]) self.y = int(v[2]) if(self.x < self.xMin): self.xMin = self.x if(self.x > self.xMax): self.xMax = self.x if(self.y<self.yMin): self.yMin = self.y if(self.y>self.yMax): self.yMax = self.y pygameX = int(self.scaleFunction(self.x,self.xMin,self.xMax,0,pygameWindowWidth)) pygameY = int(self.scaleFunction(self.y,self.yMin,self.yMax,0,pygameWindowDepth)) return pygameX,pygameY def scaleFunction(self,a,b,c,d,e): test = c-b if(test==0): a = d else: a =((a-b)/float((c-b)))*(e-d)+d return a def Run_Forever(self): while True: self.Run_Once() def Run_Once(self): self.pygameWindow.Prepare() frame = self.controller.frame() handlist = frame.hands if not handlist: print("no hand") else: num = 0 for hand in handlist: num+=1 if(num>0): self.Handle_Frame(frame) self.pygameWindow.Reveal()
class READER: def __init__(self): self.getNumberOfGestures() self.pygameWindow = PYGAME_WINDOW() self.xMin = -constants.pygameWindowWidth self.xMax = constants.pygameWindowWidth self.yMin = -constants.pygameWindowDepth self.yMax = constants.pygameWindowDepth def getNumberOfGestures(self): path, dirs, files = next(os.walk('userData')) self.numGestures = len(files) def Print_Gestures(self): for gestureNumber in range(self.numGestures): pickle_in = open("userData/train2.p","rb") gestureData = pickle.load(pickle_in) pickle_in.close() print(gestureData) def scaleValue(self,val, min, max, windowMin, windowMax): if (max - min != 0): fullWidth = max - min distanceFromMin = val - min distanceFromMinPercent = float(distanceFromMin) / float(fullWidth) windowWidth = windowMax - windowMin distanceFromWindowMin = distanceFromMinPercent * windowWidth return int(distanceFromWindowMin) else: return val def Draw_Gesture(self, gesture): self.pygameWindow.Prepare() #draw it for fingerIndex in range(5): for boneIndex in range(4): currentBone = gesture[fingerIndex,boneIndex,:] xBaseNotYetScaled = currentBone[0] yBaseNotYetScaled = currentBone[2] # ACTUALLY Z xTipNotYetScaled = currentBone[3] yTipNotYetScaled = currentBone[5] # ACTUALLY Z base_xVal = self.scaleValue(xBaseNotYetScaled, self.xMin, self.xMax, 0, constants.pygameWindowWidth) base_yVal = self.scaleValue(yBaseNotYetScaled, self.yMin, self.yMax, 0, constants.pygameWindowDepth) tip_xVal = self.scaleValue(xTipNotYetScaled, self.xMin, self.xMax, 0, constants.pygameWindowWidth) tip_yVal = self.scaleValue(yTipNotYetScaled, self.yMin, self.yMax, 0, constants.pygameWindowDepth) self.pygameWindow.Draw_Line(base_xVal,base_yVal,tip_xVal,tip_yVal, 4, (0,0,222)) self.pygameWindow.Reveal() # time.sleep(0.001) def Draw_Each_Gesture_Once(self,filename): pickle_in = open(filename,"rb") self.gestureData = pickle.load(pickle_in) pickle_in.close() print(self.gestureData.shape[3]) for gestureNumber in range(100): # if(gestureNumber % 10 == 0): print(gestureNumber) gesture = self.gestureData[:,:,:,gestureNumber] # finger, bone, xyzbasetip, gesturenumber self.Draw_Gesture(gesture) def Draw_Gestures(self): while(True): self.Draw_Each_Gesture_Once()
class READER: def __init__(self): self.xMin = 150.0 self.xMax = -150.0 self.yMin = 500.0 self.yMax = -150.0 self.pygameWindow = PYGAME_WINDOW() def Record_Files(self): path, dirs, files = next(os.walk('userData')) self.numGestures = len(files) def Print_Gestures(self): for p in range(0, self.numGestures): pickle_in = open("userData/gesture" + str(p) + ".p", "rb") gestureData = pickle.load(pickle_in) print(gestureData) def Draw_Gestures(self): while True: self.Draw_Each_Gesture_Once() def Draw_Each_Gesture_Once(self): for current_gesture in range(0, self.numGestures): self.Draw_Gesture(current_gesture) def Draw_Gesture(self, current_gesture): self.pygameWindow.Prepare() pickle_in = open("userData/gesture" + str(current_gesture) + ".p", "rb") gestureData = pickle.load(pickle_in) for i in range(0, 5): for j in range(0, 4): currentBone = gestureData[i, j, :] xBaseNotYetScaled = currentBone[0] yBaseNotYetScaled = currentBone[1] xTipNotYetScaled = currentBone[3] yTipNotYetScaled = currentBone[4] xBase = self.Scale_coordinate(xBaseNotYetScaled, 0, constants.pygameWindowWidth, self.xMin, self.xMax) yBase = self.Scale_coordinate(yBaseNotYetScaled, 0, constants.pygameWindowDepth, self.yMin, self.yMax) xTip = self.Scale_coordinate(xTipNotYetScaled, 0, constants.pygameWindowWidth, self.xMin, self.xMax) yTip = self.Scale_coordinate(yTipNotYetScaled, 0, constants.pygameWindowDepth, self.yMin, self.yMax) self.pygameWindow.Draw_Line( constants.pygameWindowWidth - xBase, constants.pygameWindowDepth - yBase, constants.pygameWindowWidth - xTip, constants.pygameWindowDepth - yTip, 1, (0, 0, 255)) self.pygameWindow.Reveal() time.sleep(0.5) def Scale_coordinate(self, var, new_min, new_max, old_min, old_max): if old_min == old_max: return new_max / 2 else: return new_min + (var - old_min) * (new_max - new_min) / (old_max - old_min)