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_Bone(self, bone, boneWidth, i, j):
base = bone.prev_joint
tip = bone.next_joint
(xBase, yBase) = self.Handle_Vector_From_Leap(base)
(xTip, yTip) = self.Handle_Vector_From_Leap(tip)
# if self.Recording_Is_Ending():
if self.currentNumberOfHands == 2:
self.gestureData[i, j, 0, self.gestureIndex] = base[0]
self.gestureData[i, j, 1, self.gestureIndex] = base[1]
self.gestureData[i, j, 2, self.gestureIndex] = base[2]
self.gestureData[i, j, 3, self.gestureIndex] = tip[0]
self.gestureData[i, j, 4, self.gestureIndex] = tip[1]
self.gestureData[i, j, 5, self.gestureIndex] = tip[2]
r = 0
g = 250
b = 0
if (self.currentNumberOfHands == 2):
r = 200
g = 0
b = 0
PYGAME_WINDOW.Draw_Line(pygameWindow, xBase, yBase, xTip, yTip,
boneWidth, r, g, b)
class READER:
def __init__(self):
# pickle_in = open('userData/train9.dat', 'rb')
# gestureData = pickle.load(pickle_in)
# print gestureData
path, dirs, files = next(os.walk('userData'))
self.numGestures = len(files)
self.pygameWindow = PYGAME_WINDOW()
def Print_Gesture(self):
for i in range(0, self.numGestures):
pickle_in = open("userData/gesture" + str(i) + ".p", 'rb')
print pickle.load(pickle_in)
def Draw_Gestures(self):
while True:
pygame.event.get()
READER.Draw_Each_Gesture_Once(self)
def Draw_Each_Gesture_Once(self):
for i in range(0, self.numGestures):
READER.Draw_Gesture(self, i)
def Draw_Gesture(self, i):
self.pygameWindow.Prepare()
pickle_in = open("userData/gesture" + str(i) + ".p", 'rb')
gesture_data = pickle.load(pickle_in)
for i in range(0, 5):
for j in range(0, 4):
xBaseNotYetScaled = -gesture_data[i, j, 0]
yBaseNotYetScaled = -gesture_data[i, j, 2]
xTipNotYetScaled = -gesture_data[i, j, 3]
yTipNotYetScaled = -gesture_data[i, j, 5]
xBase = READER.Scale(self, xBaseNotYetScaled, 1000, -1000,
-100, 700)
yBase = READER.Scale(self, yBaseNotYetScaled, 1000, -1000, 0,
700)
xTip = READER.Scale(self, xTipNotYetScaled, 1000, -1000, -100,
700)
yTip = READER.Scale(self, yTipNotYetScaled, 1000, -1000, 0,
700)
self.pygameWindow.Draw_Line(xBase, yBase, xTip, yTip, 1, 2)
self.pygameWindow.Reveal()
time.sleep(0.1)
def Scale(self, param1, old_min, old_max, new_min, new_max):
scale = (((param1 - old_min) * (new_max - new_min)) /
(old_max - old_min)) + new_min
if old_min == old_max:
return 0
if new_min == new_max:
return 0
return scale
class READER:
def __init__(self):
self.pygameWindow = PYGAME_WINDOW()
self.Count_Gestures()
def Print_Gestures(self, numGestures):
for i in range(0, numGestures):
gesture = pickle.load(open("userData/gesture" + str(i) + ".p", "rb"))
print(gesture.read())
def Count_Gestures(self):
path, dirs, files = next(os.walk("userData"))
self.numGestures = len(files)
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 Draw_Gesture(self, i):
global xMin, yMin, xMax, yMax
self.pygameWindow.Prepare()
gesture = pickle.load(open("userData/gesture" + str(i) + ".p", "rb"))
for i in range(0,5):
for j in range(0,4):
currentBone = gesture[i,j,:]
xBaseNotYetScaled = currentBone[0]
xBase = self.Scale(xBaseNotYetScaled, xMin, xMax, 0, pygameWindowWidth)
yBaseNotYetScaled = -currentBone[2]
yBase = self.Scale(yBaseNotYetScaled, yMin, yMax, pygameWindowDepth, 0)
xTipNotYetScaled = currentBone[3]
xTip = self.Scale(xTipNotYetScaled, xMin, xMax, 0, pygameWindowWidth)
yTipNotYetScaled = -currentBone[5]
yTip = self.Scale(yTipNotYetScaled, yMin, yMax, pygameWindowDepth, 0)
self.pygameWindow.Draw_Line((xBase, yBase), (xTip, yTip), 2, "blue")
self.pygameWindow.Reveal()
time.sleep(0.5)
def Draw_Each_Gesture_Once(self):
for i in range(0, self.numGestures):
self.Draw_Gesture(i)
def Draw_Gestures(self):
while True:
self.Draw_Each_Gesture_Once()
class Capture_Hands:
def __init__(self):
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), 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.waiting2record == False and self.Recording == True:
self.Save_Gesture()
print(self.gestureData)
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.waiting2record == False and self.Recording == True:
self.gestureData[f_index,
bone_type, :] = [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 DELIVERABLE:
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), dtype='f')
self.numData = 0
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.Recording_Is_Ending():
self.gestureData[finger, bone.type, 0] = base[0]
self.gestureData[finger, bone.type, 1] = base[1]
self.gestureData[finger, bone.type, 2] = base[2]
self.gestureData[finger, bone.type, 3] = tip[0]
self.gestureData[finger, bone.type, 4] = tip[1]
self.gestureData[finger, bone.type, 5] = 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.Recording_Is_Ending():
self.Save_Gesture()
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" + str(self.numData) + ".p", "wb")
pickle.dump(self.gestureData, file)
file.close()
self.numData = self.numData + 1
pass
def Update_Gesture_Data(self):
shutil.rmtree("./userData/")
os.mkdir("./userData/")
class RECORDER:
def __init__(self):
self.controller = Leap.Controller()
self.clf = pickle.load(open('userData/classifier.p', 'rb'))
self.x = 500
self.y = 400
self.xMin = 1000.0
self.xMax = -1000.0
self.yMin = 1000.0
self.yMax = -1000.0
self.numberOfGestures = 1000
self.gestureIndex = 0
self.previousNumberOfHands = 0
self.currentNumberOfHands = 0
self.gestureData = np.zeros((5, 4, 6, self.numberOfGestures),
dtype='f')
self.numGestures = 0
self.k = 0
self.pygameWindow = PYGAME_WINDOW()
self.testData = np.zeros((1, 30), dtype='f')
def CenterData(self):
allXCoordinates = self.testData[0, ::3]
meanValue = allXCoordinates.mean()
self.testData[0, ::3] = allXCoordinates - meanValue
allYCoordinates = self.testData[0, 1::3]
meanValue = allYCoordinates.mean()
self.testData[0, 1::3] = allYCoordinates - meanValue
allZCoordinates = self.testData[0, 2::3]
meanValue = allZCoordinates.mean()
self.testData[0, 2::3] = allZCoordinates - meanValue
#print "centered coordinates: " + str(self.testData[0,i]) + ", " + str(self.testData[0,i+1]) + ", " + str(self.testData[0,i+2])
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.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
baseCoords = self.Handle_Vector_From_Leap(base)
tipCoords = self.Handle_Vector_From_Leap(tip)
if ((j == 0) or (j == 3)):
#print "+ 3"
self.testData[0, self.k] = tip[0]
self.testData[0, self.k + 1] = tip[1]
self.testData[0, self.k + 2] = tip[2]
self.k = self.k + 3
if self.currentNumberOfHands == 1:
self.pygameWindow.Draw_Line(baseCoords, tipCoords, 4 - j, "green")
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)
def Recording_Is_Ending(self):
if self.currentNumberOfHands == 2:
return True
def Run_Once(self):
self.pygameWindow.Prepare()
frame = self.controller.frame()
if len(frame.hands) > 0:
self.Handle_Frame(frame)
self.CenterData()
predictedClass = self.clf.Predict(self.testData)
print(predictedClass)
self.k = 0
self.currentNumberOfHands = len(frame.hands)
self.pygameWindow.Reveal()
def Run_Forever(self):
while True:
self.Run_Once()
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
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)
class RECORDER:
def __init__(self):
self.pygameWindow = PYGAME_WINDOW()
self.numberOfGestures = 1000
self.gestureIndex = 0
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, self.numberOfGestures), 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.currentNumberOfHands == 2:
print('gesture ' + str(self.gestureIndex) + ' stored.')
self.gestureIndex = self.gestureIndex + 1
if self.gestureIndex == self.numberOfGestures:
self.Save_Gesture()
exit(0)
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.currentNumberOfHands == 2):
self.gesturedata[finger.type,bone.type,0, self.gestureIndex] = base[0]
self.gesturedata[finger.type,bone.type,1, self.gestureIndex] = base[1]
self.gesturedata[finger.type,bone.type,2, self.gestureIndex] = base[2]
self.gesturedata[finger.type,bone.type,3, self.gestureIndex] = tip[0]
self.gesturedata[finger.type,bone.type,4, self.gestureIndex] = tip[1]
self.gesturedata[finger.type,bone.type,5, self.gestureIndex] = 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.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 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=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.Get_Gesture_Number()
def Get_Gesture_Number(self):
path, dirs, files = next(os.walk('userData'))
self.numGesture = len(files)
def Print_Gestures(self):
for i in range(self.numGesture):
pickle_in = open("userData/gesture%d.p" % i, "rb")
gestureData = pickle.load(pickle_in)
pickle_in.close()
print(gestureData[0, 0, 0])
def Draw_Gestures(self):
assert (self.numGesture > 0)
self.pygameWindow = PYGAME_WINDOW()
while (True):
self.Draw_Each_Gesture_Once()
def Draw_Gesture(self, gestureIndex):
self.pygameWindow.Prepare()
pickle_in = open("userData/gesture%d.p" % gestureIndex, "rb")
gestureData = pickle.load(pickle_in)
pickle_in.close()
for i in range(5):
for j in range(4):
currentBone = gestureData[i, j, :]
xBaseNotYetScaled = currentBone[0]
yBaseNotYetScaled = currentBone[2]
xTipNotYetScaled = currentBone[3]
yTipNotYetScaled = currentBone[5]
xBase = self.Scale(xBaseNotYetScaled, constants.xMin,
constants.xMax, 0,
constants.pygameWindowWidth)
yBase = self.Scale(yBaseNotYetScaled, constants.yMin,
constants.yMax, 0,
constants.pygameWindowDepth)
xTip = self.Scale(xTipNotYetScaled, constants.xMin,
constants.xMax, 0,
constants.pygameWindowWidth)
yTip = self.Scale(yTipNotYetScaled, constants.yMin,
constants.yMax, 0,
constants.pygameWindowDepth)
self.pygameWindow.Draw_Line((xBase, yBase), (xTip, yTip),
color=(0, 0, 255))
self.pygameWindow.Reveal()
time.sleep(0.3)
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 Draw_Each_Gesture_Once(self):
for i in range(self.numGesture):
self.Draw_Gesture(i)
class READER:
def __init__(self):
self.pygameWindow_Del03 = PYGAME_WINDOW()
self.readData()
##########################################
def readData(self):
path, dirs, files = next(os.walk('userData'))
self.numGestures = len(files)
##########################################
def Print_Gestures(self):
i = 0
fileNum = str(i)
for i in range(self.numGestures):
pickleIn = open(
"/Users/Chief/Desktop/LeapDeveloperKit_2.3.1+31549_mac/LeapSDK/lib/CS228/userData/gesture"
+ fileNum + ".p", "rb", 0)
gestureData = pickle.load(pickleIn)
print(gestureData)
##########################################
def Draw_Gestures(self):
#create an infinite loop
while True:
self.Draw_Each_Gesture_Once()
##########################################
def Draw_Each_Gesture_Once(self):
xBase = 0
yBase = 0
zBase = 0
xTip = 0
yTip = 0
zTip = 0
for fileNum in range(self.numGestures):
#call Draw_Gesture
self.pygameWindow_Del03.Prepare()
#i = 0
#print(gestureData)
g = str(fileNum)
pickleIn = open(
"/Users/Chief/Desktop/LeapDeveloperKit_2.3.1+31549_mac/LeapSDK/lib/CS228/userData/gesture"
+ g + ".p", "rb", 0)
gestureData = pickle.load(pickleIn)
#right after loading gestureData
for i in range(0, 5):
for j in range(0, 4):
xBase = gestureData[i, j, 0]
yBase = gestureData[i, j, 1]
zBase = gestureData[i, j, 2]
xTip = gestureData[i, j, 3]
yTip = gestureData[i, j, 4]
zTip = gestureData[i, j, 5]
currentBone = [xBase, yBase, zBase, xTip, yTip, zTip]
xBaseNotYetScaled = currentBone[0]
yBaseNotYetScaled = currentBone[1]
xTipNotYetScaled = currentBone[3]
yTipNotYetScaled = currentBone[4]
zBaseNotYetScaled = currentBone[2]
zTipNotYetScaled = currentBone[5]
xBase = self.Scale(xBaseNotYetScaled, constants.xMin,
constants.xMax, 0,
constants.pygameWindowWidth)
yBase = self.Scale(yBaseNotYetScaled, constants.yMin,
constants.yMax,
constants.pygameWindowDepth, 0)
xTip = self.Scale(xTipNotYetScaled, constants.xMin,
constants.xMax, 0,
constants.pygameWindowWidth)
yTip = self.Scale(yTipNotYetScaled, constants.yMin,
constants.yMax,
constants.pygameWindowDepth, 0)
zBase = self.Scale(zBaseNotYetScaled, constants.xMin,
constants.xMax, 0,
constants.pygameWindowWidth)
zTip = self.Scale(zTipNotYetScaled, constants.yMin,
constants.yMax, 0,
constants.pygameWindowDepth)
self.pygameWindow_Del03.Draw_Line((0, 0, 255), xBase,
zBase, xTip, zTip, 2)
self.pygameWindow_Del03.Reveal()
time.sleep(0.1)
##########################################
def Draw_Gesture(self, curGesture):
pass
##########################################
#arg 1 should lie within a range defined by args 2 and 3.
#and should be scaled so that it lies within the new range
#defined by args 4 and 5
def Scale(self, fingerPosition, leapStart, leapEnd, appStart, appEnd):
deviceRange = leapEnd - leapStart
#xMin == xMax and yMin == yMax
if (deviceRange == 0):
curPosition = appStart
else:
appRange = appEnd - appStart
curPosition = (((fingerPosition - leapStart) * appRange) /
deviceRange) + appStart
return int(curPosition)
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 READER:
def __init__(self):
self.pygameWindow = PYGAME_WINDOW()
self.Get_Dir_Info()
self.xMin = constants.xMin
self.xMax = constants.xMax
self.yMin = constants.yMin
self.yMax = constants.yMax
def Scale(self, num, l1, h1, l2, h2):
scaledNum = num
rangeOne = h1 - l1
rangeTwo = h2 - l2
if rangeOne == 0:
return scaledNum
else:
scaledNum = (((num - l1) * rangeTwo) / rangeOne) + l2
return int(scaledNum)
def Get_Dir_Info(self):
path, dirs, files = next(os.walk('./userData'))
self.numGestures = len(files)
def Print_Gestures(self):
for g in range(self.numGestures - 1):
pickle_in = open("./userData/gesture" + str(g) + ".p", "rb")
print(pickle.load(pickle_in))
def Draw_Gesture(self, g):
pickle_in = open("./userData/gesture" + str(g) + ".p", "rb")
gestureData = pickle.load(pickle_in)
self.pygameWindow.Prepare()
for i in range(5):
for j in range(4):
currentBone = gestureData[i, j, :]
xBaseNotYetScaled = currentBone[0]
yBaseNotYetScaled = currentBone[2]
xTipNotYetScaled = currentBone[3]
yTipNotYetScaled = currentBone[5]
xBaseScaled = self.Scale(xBaseNotYetScaled, self.xMin,
self.xMax, 0,
constants.pygameWindowWidth)
xTipScaled = self.Scale(xTipNotYetScaled, self.xMin, self.xMax,
0, constants.pygameWindowWidth)
yBaseScaled = self.Scale(yBaseNotYetScaled, self.yMin,
self.yMax, 0,
constants.pygameWindowDepth)
yTipScaled = self.Scale(yTipNotYetScaled, self.yMin, self.yMax,
0, constants.pygameWindowDepth)
self.pygameWindow.Draw_Line((xBaseScaled, yBaseScaled),
(xTipScaled, yTipScaled), 2,
(0, 0, 255))
self.pygameWindow.Reveal()
time.sleep(0.25)
def Draw_Each_Gesture_Once(self):
for g in range(self.numGestures):
self.Draw_Gesture(g)
def Draw_Gestures(self):
while True:
self.Draw_Each_Gesture_Once()
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.pygameWindow_Del03 = PYGAME_WINDOW()
self.controller = Leap.Controller()
self.x = 0
self.y = 0
self.xMin = -175.0
self.xMax = 175.0
self.yMin = -175.0
self.yMax = 175.0
self.width = 5
self.color = (0, 0, 0)
self.previousNumberOfHands = 0
self.currentNumberOfhands = 0
#3D matrix of five rows, 4 columns and 6 stacks
self.gestureData = np.zeros((5, 4, 6), dtype='f')
self.gestureFile = 0
self.cleanData()
##########################################
def Handle_Vector_From_Leap(self, v):
self.x = int(v[0])
self.y = int(v[2])
scaleX = self.Scale(self.x, self.xMin, self.xMax, 0,
constants.pygameWindowWidth)
scaleY = self.Scale(self.y, self.yMin, self.yMax, 0,
constants.pygameWindowDepth)
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
#Scale the two values like you did previously
return scaleX, scaleY
##########################################
def Handle_Bone(self, bone, i, j):
#global width
base = bone.prev_joint
tip = bone.next_joint
#store the raw values
xBase = int(base[0])
yBase = int(base[1])
zBase = int(base[2])
xTip = int(tip[0])
yTip = int(tip[1])
zTip = int(tip[2])
baseInfo = self.Handle_Vector_From_Leap(base)
tipInfo = self.Handle_Vector_From_Leap(tip)
#gets the number of hands
numHands = len(self.currentNumberOfhands)
if (numHands == 1):
self.color = (0, 255, 0)
elif (numHands == 2):
self.color = (255, 0, 0)
self.pygameWindow_Del03.Draw_Line(self.color, baseInfo[0], baseInfo[1],
tipInfo[0], tipInfo[1], self.width)
#if the second hand leaves the devices field of view
#store the data in the matrix
if (self.Recording_Is_Ending()):
self.gestureData[i, j, 0] = xBase
self.gestureData[i, j, 1] = yBase
self.gestureData[i, j, 2] = zBase
self.gestureData[i, j, 3] = xTip
self.gestureData[i, j, 4] = yTip
self.gestureData[i, j, 5] = zTip
##########################################
def Handle_Finger(self, finger):
for b in range(0, 4):
bone = finger.bone(b)
i = int(finger.type)
j = b
if (b == 0):
self.width = 5
elif (b == 1):
self.width = 4
elif (b == 2):
self.width = 2
elif (b == 3):
self.width = 1
self.Handle_Bone(bone, i, j)
##########################################
def Handle_Frame(self, frame):
hand = frame.hands[0]
#print(hand)
fingers = hand.fingers
#print(str(len(fingers)))
for finger in fingers:
#print right after assignment
#print(finger)
self.Handle_Finger(finger)
if (self.Recording_Is_Ending()):
print(self.gestureData)
self.Save_Gesture()
#increments every time gesture is saved to a file
self.gestureFile += 1
##########################################
#arg 1 should lie within a range defined by args 2 and 3.
#and should be scaled so that it lies within the new range
#defined by args 4 and 5
def Scale(self, fingerPosition, leapStart, leapEnd, appStart, appEnd):
deviceRange = leapEnd - leapStart
#xMin == xMax and yMin == yMax
if (deviceRange == 0):
curPosition = appStart
else:
appRange = appEnd - appStart
curPosition = (((fingerPosition - leapStart) * appRange) /
deviceRange) + appStart
return int(curPosition)
##########################################
def Run_Forever(self):
while True:
self.Run_Once()
##########################################
def Run_Once(self):
self.pygameWindow_Del03.Prepare()
#capture a frame
frame = self.controller.frame()
#stores the current number of hands in the frame
self.currentNumberOfhands = frame.hands
#if the curr num of hands is not 0
if (self.currentNumberOfhands > 0):
#print(len(self.numberOfHands))
self.Handle_Frame(frame)
#as its about to exit and iteration store curNumHands in prevNumHands
self.previousNumberOfHands = len(self.currentNumberOfhands)
self.pygameWindow_Del03.Reveal()
##########################################
def Recording_Is_Ending(self):
#should return true when there is one hand over the device
#but there was two hands over it in the previous iteration
numHands = len(self.currentNumberOfhands)
#prevNumHands = len(self.previousNumberOfHands)
if (numHands == 1 and self.previousNumberOfHands == 2):
return True
else:
return False
##########################################
def Save_Gesture(self):
#first open the file we want
fileNum = str(self.gestureFile)
with open(
'/Users/Chief/Desktop/LeapDeveloperKit_2.3.1+31549_mac/LeapSDK/lib/CS228/userData/gesture'
+ fileNum + '.p', 'wb', 0) as f:
#pickleOut = open("gesture.p", "wb")
#then dump the data into the file
pickle.dump(self.gestureData, f)
f.close()
##########################################
def cleanData(self):
#hold the file path for the directory we are going to delete
dirName = '/Users/Chief/Desktop/LeapDeveloperKit_2.3.1+31549_mac/LeapSDK/lib/CS228/userData'
for file in os.listdir(dirName):
filePath = os.path.join(dirName, file)
if (os.path.isfile(filePath)):
os.remove(filePath)
os.rmdir(dirName)
newDir = '/Users/Chief/Desktop/LeapDeveloperKit_2.3.1+31549_mac/LeapSDK/lib/CS228/userData/'
os.makedirs(newDir)
class DELIVERABLE:
def __init__(self):
self.pygameWindow = PYGAME_WINDOW()
self.xMin = -300.0
self.xMax = 300.0
self.yMin = -300.0
self.yMax = 300.0
self.x = c.pygameWindowWidth / 2
self.y = c.pygameWindowDepth / 2
self.controller = Leap.Controller()
self.previousNumberOfHands = 0
self.currentNumberOfHands = 0
self.gestureData = np.zeros((5, 4, 6), dtype='f')
self.numGestures = 0
##### remove driectory
path = "/Users/kylemorand/Downloads/LeapDeveloperKit_2.3.1+31549_mac/LeapSDK/lib/CS228/userData"
try:
shutil.rmtree(path)
except OSError:
print("Deletion failed")
######### re add directory
try:
os.makedirs(path)
except OSError:
print("Creation failed")
def Scale(self, value, deviceMin, deviceMax, gameMin, gameMax):
if (deviceMin - deviceMax != 0 and deviceMin - value != 0):
if (value < 0):
value = (value / deviceMin) * gameMin * 2
else:
value = (value / deviceMax) * gameMax * 2
return value + 500
def Handle_Vector_From_Leap(self, v):
xVal = v[0]
yVal = v[2]
xVal = self.Scale(xVal, self.xMin, self.xMax, -c.pygameWindowWidth / 2,
c.pygameWindowWidth / 2)
yVal = self.Scale(yVal, self.yMin, self.yMax, -c.pygameWindowDepth / 2,
c.pygameWindowDepth / 2)
return int(xVal), int(yVal)
def Handle_Bone(self, bone, b, f):
base = bone.prev_joint
tip = bone.next_joint
j = b
i = f
#xBase,yBase = self.Handle_Vector_From_Leap(base)
#xTip, yTip = self.Handle_Vector_From_Leap(tip)
xBase = self.Scale(base[0], self.xMin, self.xMax,
-c.pygameWindowWidth / 2, c.pygameWindowWidth / 2)
yBase = self.Scale(base[2], self.yMin, self.yMax,
-c.pygameWindowDepth / 2, c.pygameWindowDepth / 2)
xTip = self.Scale(tip[0], self.xMin, self.xMax,
-c.pygameWindowWidth / 2, c.pygameWindowWidth / 2)
yTip = self.Scale(tip[2], self.yMin, self.yMax,
-c.pygameWindowDepth / 2, c.pygameWindowDepth / 2)
if self.currentNumberOfHands == 1:
self.pygameWindow.Draw_Line(xBase, yBase, xTip, yTip, b, c.green)
else:
self.pygameWindow.Draw_Line(xBase, yBase, xTip, yTip, b, c.red)
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]
def Handle_Finger(self, finger, finger_num):
for b in range(0, 3):
bone = finger.bone(b)
self.Handle_Bone(bone, b, finger_num)
def Handle_Frame(self, frame):
global x, y, xMin, xMax, yMin, yMax
hand = frame.hands[0]
fingers = hand.fingers
i = 0
for finger in fingers:
self.Handle_Finger(finger, i)
i += 1
if self.Recording_Is_Ending():
print(self.gestureData)
self.Save_Gesture()
def Run_Forever(self):
while True:
self.Run_Once()
def Run_Once(self):
self.pygameWindow.prepare()
frame = self.controller.frame()
self.currentNumberOfHands = len(frame.hands)
#print(len(frame.hands))
if (len(frame.hands) > 0):
self.Handle_Frame(frame)
self.previousNumberOfHands = len(frame.hands)
# pyGameX = Scale(x, xMin, xMax , 0, c.pygameWindowWidth)
# pyGameY = Scale(y, yMin, yMax, 0, c.pygameWindowDepth)
# pygameWindow.Draw_Black_Circle(x+c.pygameWindowWidth/2, c.pygameWindowDepth-y- c.pygameWindowDepth/2)
self.pygameWindow.reveal()
def Recording_Is_Ending(self):
if self.currentNumberOfHands == 1 and self.previousNumberOfHands == 2:
return True
def Save_Gesture(self):
nameString = "userData/gesture" + str(self.numGestures) + ".p"
pickle_out = open(nameString, "w")
pickle.dump(self.gestureData, pickle_out)
pickle_out.close()
self.numGestures += 1
