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 __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 __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 __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 __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
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
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
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 __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 __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 __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 __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 __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 __init__(self):
pass
self.g = 0
self.xMin = 1000.0
self.xMax = -1000.0
self.yMin = 1000.0
self.yMax = -1000.0
self.zMin = 1000.0
self.zMax = -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.gestureData = np.zeros((5, 4, 6), dtype='f')
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 __init__(self):
self.controller = Leap.Controller()
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.currentNumberOfHands = 0
self.previousNumberOfHands = 0
self.Color = (0, 255, 0)
self.Green = (0, 255, 0)
self.Red = (255, 0, 0)
self.gestureData = np.zeros((5, 4, 6), dtype='f')
self.gestureRecCount = 0
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):
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()
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 __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 __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 __init__(self):
self.controller = Leap.Controller
self.instance = PYGAME_WINDOW()
self.x = 250
self.y = 250
self.xMin = -150
self.xMax = 150
self.yMin = -150
self.yMax = 150
self.currentNumberOfHands = 0
self.previousNumberOfHands = 0
self.gestureData = np.zeros((5, 4, 6), dtype='f')
self.count = 0
self.Delete_And_Recreate_Gesture_Directory()
def __init__(self):
global Leap
global PYGAME_WINDOW
self.controller = Leap.Controller()
self.pygameWindow = PYGAME_WINDOW()
self.x = (pygameWindowWidth/2)
self.y = (pygameWindowDepth/2)
self.xRawMin = -70
self.xRawMax = 244
self.yRawMin = -120
self.yRawMax = 204
self.xScaledMin = 0
self.xScaledMax = 800
self.yScaledMin = 0
self.yScaledMax = 650
pass
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)
import sys
sys.path.insert(0, "..")
import Leap
import constants
import random
from pygameWindow_Del03 import PYGAME_WINDOW
from Recorder import RECORDER
deliverable = RECORDER(Leap.Controller(), PYGAME_WINDOW(), 400, 400, 800, -800,
800, -800)
deliverable.Run_Forever()
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")
import sys
sys.path.insert(0, "..")
import Leap
from pygameWindow_Del03 import PYGAME_WINDOW
from Recorder import RECORDER
import random
import pygame
import os
new_derivable = RECORDER(PYGAME_WINDOW(), Leap.Controller(), 540, 360, 1000,
1000.0, -1000.0, 1000.0, -1000.0)
new_derivable.Run_Forever()
class RECORDER:
def __init__(self):
self.controller = Leap.Controller()
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.currentNumberOfHands = 0
self.previousNumberOfHands = 0
self.Color = (0,255,0)
self.Green = (0,255,0)
self.Red = (255,0,0)
self.numberOfGestures = 1000
self.gestureData = np.zeros((5,4,6,self.numberOfGestures),dtype='f')
self.gestureIndex = 0
def Remove_Dir(self):
fileList = glob.glob("./userData/*")
for file in fileList:
os.remove(file)
os.rmdir("./userData")
def Make_Dir(self):
os.mkdir("./userData")
def Save_Gesture(self):
gestureString = "./userData/test6.p"
pickle_out = open(gestureString,"wb")
pickle.dump(self.gestureData,pickle_out)
pickle_out.close()
def Recording_Is_Ending(self):
if (self.currentNumberOfHands < self.previousNumberOfHands):
return True
else:
return False
def Handle_Frame(self, frame):
handList = frame.hands
self.currentNumberOfHands = len(handList)
if (self.currentNumberOfHands > 1):
self.Color = self.Red
else:
self.Color = self.Green
DomHand = handList[0]
fingers = DomHand.fingers
i = 0
for finger in fingers:
self.Handle_Finger(finger, i)
i = i + 1
if (self.currentNumberOfHands == 2):
time.sleep(.005)
print('gesture ' + str(self.gestureIndex) + ' stored.')
#if (self.gestureIndex == 0 or self.gestureIndex == 99):
# print(self.gestureData[:,:,:,self.gestureIndex])
self.gestureIndex = self.gestureIndex + 1
if (self.gestureIndex == self.numberOfGestures):
self.Save_Gesture()
exit(0)
def Handle_Finger(self, finger, i):
for b in range(4):
self.Handle_Bone(finger.bone(b), i, b)
def Handle_Bone(self, bone, i, j):
tip = bone.next_joint
base = bone.prev_joint
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]
xTip, yTip = self.Handle_Vector_From_Leap(tip)
xBase, yBase = self.Handle_Vector_From_Leap(base)
#invert B so thickest is at wrist
invertedI = (4 - j) * 2
self.pygameWindow.Draw_Black(self.Color, xBase, yBase, xTip, yTip, invertedI)
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 = self.Scale(int(v[0]), self.xMin, self.xMax, 0, 600)
pygameY = self.Scale(int(v[2]), self.yMin, self.yMax, 0, 600)
return pygameX, pygameY
def Scale(self, value, before_min, before_max, after_min, after_max):
if ((before_max - before_min) <= 0):
return 0
scaleValue = (float(value) - float(before_min)) / (float(before_max) - float(before_min))
scaledPointValue = (scaleValue * (after_max - after_min)) + after_min
return int(scaledPointValue)
def Run_Forever(self):
while True:
self.pygameWindow.Prepare()
frame = self.controller.frame()
hands = frame.hands
if (not hands.is_empty):
self.Handle_Frame(frame)
self.previousNumberOfHands = self.currentNumberOfHands
self.pygameWindow.Reveal()
##yMax = -1000.0
##def Perturb_Circle_Position():
## global x, y
## fourSidedDieRoll = randint(1,4)
## if fourSidedDieRoll == 1:
## x -= 1
## elif fourSidedDieRoll == 2:
## x += 1
## elif fourSidedDieRoll == 3:
## y -= 1
## else:
## y += 1
pygameWindow = PYGAME_WINDOW()
print(pygameWindow)
previousNumberOfHands = 0
currentNumberOfHands = 0
fileNumber = 0
def Handle_Frame(frame):
global x, y, xMin, xMax, yMin, yMax, currentNumberOfHands
##handlist = frame.hands
##numberOfHands = 0
## print(str(hand))
currentNumberOfHands = len(frame.hands)
hand = frame.hands[0]
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()
