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)
