def proyManoXY(mano):
#Vectores
direccion = mano.direction
posPalma = mano.palm_position
normPalma = mano.palm_normal
dedos = mano.fingers
pulgar = dedos[0] #Pulgar
indice = dedos[1] #Indice
medio = dedos[2] #Medio
anular = dedos[3] #Anular
menique = dedos[4] #Menique
#componentes en x (flotantes)
xDireccion = direccion.dot(x)
xPosPalma = posPalma.dot(x)
xNormPalma = normPalma.dot(x)
#componentes en y
yDireccion = direccion.dot(y)
yPosPalma = posPalma.dot(y)
yNormPalma = normPalma.dot(y)
proyeccion = {}
proyeccion["direccion"] = Leap.Vector(xDireccion, yDireccion, 0)
proyeccion["normal"] = Leap.Vector(xNormPalma, yNormPalma, 0)
#Impresiones
#print("Datos Originales");
#print(direccion.to_tuple())
#print(normPalma.to_tuple())
#print("Proyeccion a XY")
#print(proyeccion["direccion"].to_tuple())
#print(proyeccion["normal"].to_tuple())
return proyeccion()
def on_frame(self, controller):
# Get the most recent frame and report some basic information
frame = controller.frame()
# Get hands
for hand in frame.hands:
# No left hand inputs allowed
if hand.is_left:
# if a left hand is detected, then reset
print("Left hand shown, reset robot arm")
angles = "0 0 20 0 0 0"
self.serialConnection.write(angles)
time.sleep(2.0)
break
# We need to return the palm position, or alternatively the wrist position
hand.palm_position
# We need to return direction vector of the hand
hand.direction
# Return the state of the fist
self.is_fist(hand)
# We need to return the direction vector of the arm
hand.arm.direction
# the yaw can be deduced from this
wrist_movement_direction = Leap.Vector(0, 0, 0)
if self.previous_wrist_position != Leap.Vector(0, 0, 0):
wrist_movement_direction = hand.arm.wrist_position - self.previous_wrist_position
# move it forward
self.theta1 = self.theta1 - wrist_movement_direction.z * VEL_SCALE
self.theta2 = self.theta2 - wrist_movement_direction.y * VEL_SCALE
#self.theta3 = self.theta3 - wrist_movement_direction.y*VEL_SCALE
print(wrist_movement_direction)
self.previous_wrist_position = hand.arm.wrist_position
# Call Richard's math function
#theta_values = end_effector_position(hand.arm.wrist_position, hand.direction)
#theta1, theta2 = calculateInverseKinematics(hand.arm.wrist_position.y, -hand.arm.wrist_position.z)
if self.is_fist(hand) == True:
pincer_value = PINCER_ANGLE
else:
pincer_value = 0
angles = "0 " + str(
self.theta1) + " " + str(20 + self.theta1) + " " + str(
self.theta2) + " " + "0 " + str(pincer_value)
#angles.strip()
print(angles)
self.serialConnection.write(angles)
time.sleep(FRAME_PAUSE)
def on_frame(self, controller):
count = 50
position = Leap.Vector()
direction = Leap.Vector()
velocity = Leap.Vector()
for i in range(0, count - 1):
hand = controller.frame(i).hands
if hand[0].is_valid:
position = position + hand[0].palm_position
direction = direction + hand[0].direction
velocity = velocity + hand[0].palm_velocity
confidence = controller.frame().hands[0].confidence
grab = controller.frame().hands[0].grab_strength
position = position / count
direction = direction / count
velocity = velocity / count
mutex.acquire()
try:
leap_context["velocity"] = velocity
leap_context["position"] = position
leap_context["direction"] = direction
leap_context["box"] = controller.frame().interaction_box
leap_context["confidence"] = confidence
leap_context["grab"] = grab
finally:
mutex.release()
def __init__(self, scale=1. / 4 / 10., offset=b2Vec2(6.0, 0.)):
self.__thumbPos = Leap.Vector(0., 0., 0.)
self.__indexPos = Leap.Vector(0., 0., 0.)
self.__time = 0.
self.controller = Leap.Controller()
self.scale = scale
self.offset = offset
super(Leaper, self).__init__()
def onFrame(self, controller):
# Get the most recent frame and report some basic information
frame = controller.frame()
hands = frame.hands()
numHands = len(hands)
print "Frame id: %d, timestamp: %d, hands: %d" % (
frame.id(), frame.timestamp(), numHands)
if numHands >= 1:
# Get the first hand
hand = hands[0]
# Check if the hand has any fingers
fingers = hand.fingers()
numFingers = len(fingers)
if numFingers >= 1:
# Calculate the hand's average finger tip position
pos = Leap.Vector(0, 0, 0)
for finger in fingers:
tip = finger.tip()
pos.x += tip.position.x
pos.y += tip.position.y
pos.z += tip.position.z
pos = Leap.Vector(pos.x / numFingers, pos.y / numFingers,
pos.z / numFingers)
print "Hand has %d fingers with average tip position (%f, %f, %f)" % (
numFingers, pos.x, pos.y, pos.z)
# Check if the hand has a palm
palmRay = hand.palm()
if palmRay is not None:
# Get the palm position and wrist direction
palm = palmRay.position
wrist = palmRay.direction
print "Palm position (%f, %f, %f)" % (palm.x, palm.y, palm.z)
# Check if the hand has a normal vector
normal = hand.normal()
if normal is not None:
# Calculate the hand's pitch, roll, and yaw angles
pitchAngle = math.atan2(normal.z,
normal.y) * 180 / math.pi + 180
rollAngle = math.atan2(normal.x,
normal.y) * 180 / math.pi + 180
yawAngle = math.atan2(wrist.z,
wrist.x) * 180 / math.pi - 90
# Ensure the angles are between -180 and +180 degrees
if pitchAngle > 180: pitchAngle -= 360
if rollAngle > 180: rollAngle -= 360
if yawAngle > 180: yawAngle -= 360
print "Pitch: %f degrees, roll: %f degrees, yaw: %f degrees" % (
pitchAngle, rollAngle, yawAngle)
# Check if the hand has a ball
ball = hand.ball()
if ball is not None:
print "Hand curvature radius: %f mm" % ball.radius
def take_input():
print "Taking input."
controller = Leap.Controller()
count = 0
last_frame = 0
while last_frame < 1:
string = ''
frame = controller.frame()
if frame.id != last_frame:
last_frame = frame.id
fingers_1 = []
fingers_2 = []
for index_type in range(0,
1): #Sort the fingers from thumb to pinky.
fingers_1.append(frame.hands.leftmost)
fingers_2.append(frame.hands.rightmost)
fingers_1.append(frame.hands.leftmost.palm_position)
fingers_2.append(frame.hands.rightmost.palm_position)
hand_right = fingers_2[0]
hand_left = fingers_1[0]
for finger_right in hand_right.fingers:
bone_right = finger_right.bone(3)
distance_right = fingers_2[1].distance_to(
bone_right.next_joint)
string += (str(distance_right) + ', ')
sudut = Leap.Vector(finger_right.tip_position - fingers_2[1])
b = str(sudut).replace('(', '')
c = b.replace(')', '')
string += (str(c) + ', ')
for finger_left in hand_left.fingers:
bone_left = finger_left.bone(3)
distance_left = fingers_1[1].distance_to(bone_left.next_joint)
string += (str(distance_left) + ', ')
sudut = Leap.Vector(finger_left.tip_position - fingers_1[1])
b = str(sudut).replace('(', '')
c = b.replace(')', '')
if count < 4:
string += (c + ', ')
else:
string += (c)
count += 1
print(string)
string_list = string.split(',')
print(string_list)
last_frame += 1
results = map(float, string_list)
dicari = np.array(results)
baru = np.reshape(dicari, (-1, 1))
baru_lagi = np.reshape(dicari, (1, -1))
hasil_knn = knn.predict(baru_lagi)
print(hasil_knn)
def mom_grandma_dad_grandpa(frame):
global lastWord
for hand in frame.hands:
if len(frame.hands) == 1:
if hand.sphere_radius > 80:
handChirality = 1 if hand.is_right else -1
if hand.palm_normal.angle_to(Leap.Vector(-1,0,0)) < Leap.PI/6 if handChirality==1 else hand.palm_normal.angle_to(Leap.Vector(1,0,0)) < Leap.PI/6:
if Leap.PI/6 < hand.direction.angle_to(Leap.Vector(0,0,-1)) < 3*Leap.PI/8:
"""
for gesture in frame.gestures():
if gesture.type == Leap.Gesture.TYPE_CIRCLE:
circle = CircleGesture(gesture)
if (circle.pointable.direction.angle_to(
circle.normal) <= Leap.PI / 2) if handChirality == -1 else not (
circle.pointable.direction.angle_to(circle.normal) <= Leap.PI / 2): # clockwise
if circle.state != Leap.Gesture.STATE_START:
if circle.progress >= 1.25:
if lastWord != "grandma":
time.sleep(0.5)
print "grandma"
player('grandma')
lastWord = "grandma"
return True
"""
if lastWord != "mom":
time.sleep(0.5)
print "mom"
player('mom')
lastWord = "mom"
time.sleep(0.25)
return True
if 5*Leap.PI/12 < hand.direction.angle_to(Leap.Vector(0,0,-1)) < 2*Leap.PI/3:
"""
for gesture in frame.gestures():
if gesture.type == Leap.Gesture.TYPE_CIRCLE:
circle = CircleGesture(gesture)
if (circle.pointable.direction.angle_to(
circle.normal) <= Leap.PI / 2) if handChirality == -1 else not (
circle.pointable.direction.angle_to(circle.normal) <= Leap.PI / 2): # clockwise
if circle.state != Leap.Gesture.STATE_START:
if circle.progress >= 1.25:
if lastWord != "grandpa":
print "grandpa"
player('grandpa')
lastWord = "grandpa"
return True
"""
if lastWord != "dad":
print "dad"
player('dad')
lastWord = "dad"
time.sleep(1)
return True
return False
def get_all_fingers(self, frame):
if not frame.hands.is_empty:
hands_fingers = []
for hand in frame.hands:
this_hand = []
for finger in hand.fingers:
finger_pos = Leap.Vector()
finger_pos += finger.tip_position
this_hand.append((int(finger_pos[0]), int(finger_pos[1]),
int(finger_pos[3])))
finger_vel = Leap.Vector()
finger_vel += finger.tip_velocity
hands_fingers.append(this_hand)
return hands_fingers
def leap_to_world(self, leap_point, iBox):
leap_point.z *= -1.0
#right-hand to left-hand rule
normalized = iBox.normalize_point(leap_point, False)
normalized = normalized + Leap.Vector(0.5, 0, 0.5)
#recenter origin
return normalized * 100.0
def on_frame(self, controller):
# Get the most recent frame
frame = controller.frame()
# Need exactly one hand for this gesture
if len(frame.hands) is not 1:
del self.history[:]
return
hand = frame.hands[0]
# About five fingers must be visible
if len(hand.fingers) < 4:
del self.history[:]
return
self.history.append(hand.stabilized_palm_position)
# Limit history size
if len(self.history) > self.history_size:
self.history = self.history[:-self.history_size]
# Activate the gesture if there's enough change
variation = Leap.Vector()
for i in range(1, len(self.history)):
variation += self.history[i] - self.history[i - 1]
if variation.magnitude >= self.threshold:
self.change_color(hand.stabilized_palm_position)
def leap_notes(self, frame, last_leap_notes):
leap_notes = {}
if not frame.hands.is_empty:
for finger in frame.fingers:
finger_pos = Leap.Vector()
finger_pos += finger.tip_position
finger_vel = Leap.Vector()
finger_vel += finger.tip_velocity
leap_notes = self.get_cur_leap_notes(finger, last_leap_notes,
finger_pos, finger_vel,
leap_notes)
missing_notes = self.get_missing_notes(last_leap_notes, leap_notes)
if len(missing_notes) != 0:
for note in missing_notes:
leap_notes[note] = ["off", self.last_y_pos]
return leap_notes
def on_frame(self, controller):
# Get the most recent frame and report some basic information
frame = controller.frame()
print "Frame id: %d, timestamp: %d, hands: %d, fingers: %d, tools: %d" % (
frame.id, frame.timestamp, len(frame.hands), len(
frame.fingers), len(frame.tools))
if not frame.hands.empty:
# Get the first hand
hand = frame.hands[0]
# Check if the hand has any fingers
fingers = hand.fingers
if not fingers.empty:
# Calculate the hand's average finger tip position
avg_pos = Leap.Vector()
for finger in fingers:
avg_pos += finger.tip_position
avg_pos /= len(fingers)
print "Hand has %d fingers, average finger tip position: %s" % (
len(fingers), avg_pos)
# Get the hand's sphere radius and palm position
print "Hand sphere radius: %f mm, palm position: %s" % (
hand.sphere_radius, hand.palm_position)
# Get the hand's normal vector and direction
normal = hand.palm_normal
direction = hand.direction
# Calculate the hand's pitch, roll, and yaw angles
print "Hand pitch: %f degrees, roll: %f degrees, yaw: %f degrees\n" % (
direction.pitch * Leap.RAD_TO_DEG,
normal.roll * Leap.RAD_TO_DEG, direction.yaw * Leap.RAD_TO_DEG)
def on_frame(self, controller):
# Get the most recent frame and report some basic information
frame = controller.frame()
if self.state == 1 or self.state == 2: #recording state
if not frame.hands.is_empty:
self.noin = 0
# Get the first hand
hand = frame.hands[0]
# Check if the hand has any fingers
fingers = hand.fingers
if not fingers.is_empty:
# Calculate the hand's average finger tip position
if len(fingers) in (1, 2):
avg_pos = Leap.Vector()
for finger in fingers:
avg_pos += finger.tip_position
avg_pos /= len(fingers)
coords = avg_pos.to_tuple()
if coords[2] < 40:
self.xcor.append(coords[0])
self.ycor.append(coords[1])
print "Recorded X: %d, Y: %d" % (coords[0],
coords[1])
else:
self.noin += 1
if self.noin >= 100:
if self.state == 1:
self.xsav = self.xcor
self.ysav = self.ycor
self.xcor = []
self.ycor = []
print "Recording complete"
self.state = 3
self.wait = 0
self.noin = 0
elif self.state == 2:
print "Signature complete"
diff = self.sigcomp()
print int(diff)
if diff > 50 or diff == -1:
print "You signature was not accepted, try again"
self.state = 3
self.wait = 0
self.noin = 0
self.xcor = []
self.ycor = []
else:
print "Signature was accepted"
raw_input()
if self.state == 3:
self.wait += 1
w = 5 - int(self.wait / 40)
if w != self.lastwait:
print "Signing in %d" % w
self.lastwait = w
if self.wait > 200:
self.state = 2
self.wait = 0
def __prototype_thumb_angle(self):
thumb = self.hand.fingers[Leap.Finger.TYPE_THUMB]
point_a = thumb.bone(Leap.Bone.TYPE_PROXIMAL).prev_joint
point_b = thumb.bone(Leap.Bone.TYPE_INTERMEDIATE).prev_joint
point_c = thumb.bone(Leap.Bone.TYPE_INTERMEDIATE).next_joint
point_d = thumb.bone(Leap.Bone.TYPE_DISTAL).next_joint
ab = Leap.Vector(point_b.x - point_a.x, point_b.y - point_a.y,
point_b.z - point_a.z)
cd = Leap.Vector(point_d.x - point_c.x, point_d.y - point_c.y,
point_d.z - point_c.z)
dot_product = ab.x * cd.x + ab.y * cd.y + ab.z * cd.z
magnitude_ab = math.sqrt(pow(ab.x, 2) + pow(ab.y, 2) + pow(ab.z, 2))
magnitude_cd = math.sqrt(pow(cd.x, 2) + pow(cd.y, 2) + pow(cd.z, 2))
cos_angle = dot_product / (magnitude_ab * magnitude_cd)
angle = math.acos(cos_angle)
return angle
def getMsg(self):
#frameId
self.LeapFrameMsg.frameID = self.frame.id
#device vector:x,y,z,yaw,pitch,roll
vector = Leap.Vector()
#cartesian coordinates
self.LeapFrameMsg.vector.cartesian = vector.to_float_array()
#angular coordinates
self.LeapFrameMsg.vector.angular = [vector.pitch, vector.yaw, vector.roll]
#time stamp
self.LeapFrameMsg.timeStamp = self.frame.timestamp
#hands
for hand in self.frame.hands:
self.LeapFrameMsg.hands.append(self.getHand(hand))
#fingers
for finger in self.frame.fingers:
self.LeapFrameMsg.fingers.append(self.getFinger(finger))
#pointables
for pointable in self.frame.pointables:
self.LeapFrameMsg.pointables.append(self.getPointable(pointable))
return self.LeapFrameMsg
def get_fingertip_list(self, frame):
finger_list = []
for finger in frame.fingers:
finger_pos = Leap.Vector()
finger_pos += finger.tip_position
finger_list.append((int(finger_pos[0]), int(finger_pos[1])))
return sorted(finger_list)
def generateFingerData(hand, handCnt, numHands):
fingers = hand.fingers()
numFingers = len(fingers)
fingerCnt = 0
if numFingers >= 1:
fingerData = '"fingers":[ '
pos = Leap.Vector(0, 0, 0)
dir = Leap.Vector(0, 0, 0)
for finger in fingers:
tip = finger.tip()
id = finger.id()
width = finger.width()
pos.x = tip.position.x
pos.y = tip.position.y
pos.z = tip.position.z
velocity = finger.velocity()
fingerData += '{ "id":' + str(id) + ','
fingerData += '"isTool": "' + str(finger.isTool()) + '",'
fingerData += '"length":' + str(finger.length()) + ','
fingerData += '"tip": {'
fingerData += '"direction":{'
fingerData += '"x":' + str(tip.direction.x) + ','
fingerData += '"y":' + str(tip.direction.y) + ','
fingerData += '"z":' + str(tip.direction.z)
fingerData += '}, "position":{'
fingerData += '"x":' + str(tip.position.x) + ','
fingerData += '"y":' + str(tip.position.y) + ','
fingerData += '"z":' + str(tip.position.z) + '} '
fingerData += '}, "velocity":{'
fingerData += '"x":' + str(velocity.x) + ','
fingerData += '"y":' + str(velocity.y) + ','
fingerData += '"z":' + str(velocity.z) + '},'
fingerData += '"width":' + str(width) + '}'
fingerCnt += 1
if (fingerCnt != numFingers):
fingerData += ','
fingerData += '],'
else:
fingerData = '"fingers": null,'
return fingerData
def modal(self, context, event):
if event.type == 'ESC':
return self.cancel(context)
if event.type == 'TIMER':
controller = self.controller
frame = controller.frame()
if self.handID is not None:
# Trying to track hand.
hand = frame.hand(self.handID)
if hand.is_valid:
# Hand tracking successfull. Checking fingers.
if self.isGesture(hand):
# Finger tracking succeeded. Update object.
self.updateObject(frame, context)
else:
# Finger tracking failed. Assuming end of gesture.
# Reseting state
self.handID = None
self.startPosition = None
self.startOrientierung = None
self.ob = None
self.startLocation = None
self.startRotation = None
else:
# Hand tracking failed. Searching for gesture.
for hand in frame.hands:
if self.isGesture(hand):
# Replacement hand found. Updating state and object.
self.handID = hand.id
# Update object
self.updateObject(frame, context)
break
# No replacement hand/gesture found. Assuming hand moved out of sight. Resetting state and object.
# TODO
else:
# No hand is being tracked. Searching for gesture.
for hand in frame.hands:
if self.isGesture(hand):
# Gesture found. Memorizing starting position and orientation.
print("New gesture found.")
self.handID = hand.id
self.startPosition = hand.palm_position
orientation = Leap.Vector()
orientation.pitch = hand.direction.pitch
orientation.yaw = hand.direction.yaw
orientation.roll = hand.palm_normal.roll
self.startOrientierung = orientation
self.ob = bpy.context.object
self.ob.rotation_mode = 'QUATERNION'
self.startLocation = self.ob.location.copy()
self.startRotation = self.ob.rotation_quaternion.copy()
break
return {'PASS_THROUGH'}
def __init__(self, threshold=35, history_size=10):
Leap.Listener.__init__(self)
self.hand_origin = Leap.Vector()
self.history = []
self.history_size = history_size
self.threshold = threshold
def get_fingers_avg_pos(self, hand):
fingers = hand.fingers
if not fingers.is_empty and len(fingers) != -1:
avg_pos = Leap.Vector()
for finger in fingers:
avg_pos += finger.stabilized_tip_position
avg_pos /= len(fingers)
return avg_pos
def hand_rotator():
previous_frame = None
while True:
hand = (yield)
if previous_frame and hand and hand.rotation_probability(
previous_frame) > 0.1:
view = list(cmd.get_view())
matrix = hand.rotation_matrix(previous_frame)
matrix *= Leap.Matrix(Leap.Vector(*view[0:3]),
Leap.Vector(*view[3:6]),
Leap.Vector(*view[6:9]))
view[:9] = matrix.to_array_3x3()
cmd.set_view(view)
if hand:
previous_frame = hand.frame
else:
previous_frame = None
def on_init(self, controller):
print "Initialized"
self.serialConnection = None
self.previous_angles = []
self.previous_wrist_position = Leap.Vector(0, 0, 0)
self.theta1 = 0
self.theta2 = 0
self.theta3 = 0
def onFrame(self, controller):
# Get the most recent frame and report some basic information
frame = controller.frame()
hands = frame.hands()
numHands = len(hands)
print "Frame id: %d, timestamp: %d, hands: %d" % (
frame.id(), frame.timestamp(), numHands)
if numHands >= 1:
# Get the first hand
hand = hands[0]
# Check if the hand has any fingers
fingers = hand.fingers()
numFingers = len(fingers)
if numFingers >= 1:
# Calculate the hand's average finger tip position
pos = Leap.Vector(0, 0, 0)
for finger in fingers:
tip = finger.tip()
pos.x += tip.position.x
pos.y += tip.position.y
pos.z += tip.position.z
pos = Leap.Vector(pos.x / numFingers, pos.y / numFingers,
pos.z / numFingers)
msg = "Hand has %d fingers with average tip position (%f, %f, %f)" % (
numFingers, pos.x, pos.y, pos.z)
print msg
self.zmqSocket.send_json({"message": msg})
# Check if the hand has a palm
palmRay = hand.palm()
if palmRay is not None:
# Get the palm position and wrist direction
palm = palmRay.position
wrist = palmRay.direction
direction = ""
if wrist.x > 0:
direction = "left"
else:
direction = "right"
print "Hand is pointing to the %s with palm position (%f, %f, %f)" % (
direction, palm.x, palm.y, palm.z)
def get_current(self, frame):
hand = frame.hands[0]
fingers = hand.fingers
fingerList = []
for finger in fingers:
finger_pos = Leap.Vector()
finger_pos += finger.tip_position
fingerList.append((int(finger_pos[0]), int(finger_pos[1])))
return fingerList[0][1]
def main():
controller = Leap.Controller()
controller.enable_gesture(Leap.Gesture.TYPE_SCREEN_TAP)
mainMonitor = CGDisplayBounds(CGMainDisplayID())
# err, ids, count = CGGetOnlineDisplayList(10,None,None)
# WIDTH = 0
# HEIGHT = 0
# for id in ids:
# monitor = CGDisplayBounds(id)
# WIDTH += monitor.size.width
# HEIGHT += monitor.size.height
FPS = 50
FARLEFT = -300
FARRIGHT = 300
TOP = 500
BOTTOM = 100
BACKGROUND = -25
SCREENWIDTH = mainMonitor.size.width
SCREENHEIGHT = mainMonitor.size.height
last_time = time.time()
touched = False
while True:
new_time = time.time()
sleep_time = ((1000.0 / FPS) - (new_time - last_time)) / 1000.0
if sleep_time > 0:
time.sleep(sleep_time)
last_time = new_time
frame = controller.frame()
if not frame.hands.is_empty:
hand = frame.hands[0]
fingers = hand.fingers
if not fingers.is_empty:
num_fingers = 0
avg_pos = Leap.Vector()
for finger in fingers:
num_fingers += 1
avg_pos += finger.tip_position
avg_pos /= len(fingers)
posx = (SCREENWIDTH) / (FARRIGHT - FARLEFT) * (avg_pos[0] -
FARLEFT)
posy = (SCREENHEIGHT) / (BOTTOM - TOP) * (avg_pos[1] - TOP)
# Limit to screen
posx = 0 if posx < 0 else posx
posx = SCREENWIDTH if posx > SCREENWIDTH else posx
posy = 0 if posy < 0 else posy
posy = SCREENHEIGHT if posy > SCREENHEIGHT else posy
if num_fingers == 1:
mousemove(posx, posy)
if avg_pos[2] < BACKGROUND:
if touched == False:
mouseclick(posx, posy)
touched = True
else:
touched = False
def take_input(label):
print "Taking input."
file_dataset = open('angka_sudut_panjang.txt','a')
file_temp = open('temp_dataset.txt','a')
file_temp.write(str(label) + " ")
controller = Leap.Controller()
count = 0
last_frame = 0
while count < 20:
frame = controller.frame()
if frame.id != last_frame:
print ".",
last_frame = frame.id
fingers_1 = []
fingers_2 = []
for index_type in range(0,1): #Sort the fingers from thumb to pinky.
fingers_1.append(frame.hands.leftmost)
fingers_2.append(frame.hands.rightmost)
fingers_1.append(frame.hands.leftmost.palm_position)
fingers_2.append(frame.hands.rightmost.palm_position)
hand_right = fingers_2[0]
hand_left = fingers_1[0]
file_dataset.write(str(label))
for finger_right in hand_right.fingers:
bone_right = finger_right.bone(3)
distance_right = fingers_2[1].distance_to(bone_right.next_joint)
file_dataset.write(', '+ str(distance_right))
sudut = Leap.Vector(finger_right.tip_position - fingers_2[1])
b = str(sudut).replace('(', '')
c = b.replace(')', '')
file_dataset.write(', ' + c)
for finger_left in hand_left.fingers:
bone_left = finger_left.bone(3)
distance_left = fingers_1[1].distance_to(bone_left.next_joint)
file_dataset.write(', '+ str(distance_left))
sudut = Leap.Vector(finger_left.tip_position - fingers_1[1])
b = str(sudut).replace('(', '')
c = b.replace(')', '')
file_dataset.write(', ' + c)
file_dataset.write("\n")
count +=1
def get_pressed_keys(self, frame):
indexes_and_heights = []
if not frame.hands.is_empty:
for finger in frame.fingers:
finger_pos = Leap.Vector()
finger_pos += finger.tip_position
index = self.get_note_index(finger_pos[0])
y_pos = finger_pos[1]
indexes_and_heights.append((index, y_pos))
return indexes_and_heights
def on_frame(self, controller):
if (self.count == self.AVG):
valid_fingers = 0
average = Leap.Vector()
for i in range(0, self.AVG - 1):
index_finger = controller.frame(i).fingers.finger_type(
Finger.TYPE_INDEX)[0]
# index_finger = indexFingerList[0]
pinky_finger = controller.frame(i).fingers.finger_type(
Finger.TYPE_PINKY)[0]
#pinky_finger = pinky_fingerList[0]
if (pinky_finger.is_valid and pinky_finger.direction.z < 0):
if (time.time() - self.last_click > 1):
print "last %d", self.last_click
print "this %d", time.time()
self.action.click(index_finger)
self.clicked = True
self.last_click = time.time()
if (not pinky_finger.is_valid
or not pinky_finger.direction.z < 0):
if (self.clicked == True):
self.clicked = False
self.action.unclick(index_finger)
if (index_finger.is_valid and index_finger.direction.z < 0):
average += index_finger.tip_position
valid_fingers += 1
if (self.use_vertscroll):
prev_finger = controller.frame(i + 1).fingers.finger_type(
Finger.TYPE_INDEX)[0]
if (prev_finger.is_valid and index_finger.is_valid):
diff = prev_finger.tip_position.y - index_finger.tip_position.y
# print diff
if (math.fabs(diff) > self.SCROLL_THRESHOLD):
self.action.scroll(math.copysign(1, -diff))
elif index_finger.is_valid and index_finger.type == Leap.Finger.TYPE_INDEX:
roll = finger.direction.roll + self.roll_offset
if math.fabs(roll) > self.vert_scroll_limit:
self.action.scroll(self.vert_scroll_limit - roll)
print roll
average /= valid_fingers
if not valid_fingers == 0:
self.action.mouse(average, index_finger)
count = 0
else:
self.count += 1
def love(frame):
global lastWord
for hand in frame.hands:
angle_to_index = 0.0
angle_to_middle = 0.0
angle_to_ring = 0.0
angle_to_pinky = 0.0
projection_on_direction_thumb = 0.0
for finger in hand.fingers:
if finger.type == TYPE_THUMB:
for i in xrange(4):
bone_i = finger.bone(i)
if bone_i.type == TYPE_PROXIMAL:
projection_on_direction_thumb = bone_i.direction.dot(hand.direction) / hand.direction.magnitude
elif finger.type == TYPE_INDEX:
for i in xrange(4):
bone = finger.bone(i)
if bone.type == TYPE_DISTAL:
angle_to_index = bone.direction.angle_to(hand.direction)
elif finger.type == TYPE_MIDDLE:
for i in xrange(4):
bone = finger.bone(i)
if bone.type == TYPE_DISTAL:
angle_to_middle = bone.direction.angle_to(hand.direction)
elif finger.type == TYPE_RING:
for i in xrange(4):
bone = finger.bone(i)
if bone.type == TYPE_DISTAL:
angle_to_ring = bone.direction.angle_to(hand.direction)
else:
for i in xrange(4):
bone = finger.bone(i)
if bone.type == TYPE_DISTAL:
angle_to_pinky = bone.direction.angle_to(hand.direction)
index_up = False if angle_to_index < 1 else True
middle_up = False if angle_to_middle < 1 else True
ring_up = False if angle_to_ring < 1 else True
pinky_up = False if angle_to_pinky < 1 else True
thumb_up = False if projection_on_direction_thumb < -.75 else True
if index_up and not middle_up and not ring_up and pinky_up and thumb_up:
if abs(hand.palm_normal.angle_to(Leap.Vector(0,-1,0))) * Leap.RAD_TO_DEG <= 30:
if lastWord != 'love':
print 'I love you'
lastWord = 'love'
player('ily')
return True
return False
def on_frame(self, controller):
frame = controller.frame()
interactionBox = frame.interaction_box
if (frame.pointables.is_empty == True):
self.position = Leap.Vector(0, 0, 0)
elif (frame.pointables.is_empty == False):
for pointable in frame.pointables:
pointable = frame.pointables.frontmost
self.position = pointable.tip_position
print(self.position)
return self.position
