def on_frame(self, controller): # Get the most recent frame and report some basic information frame = controller.frame() global connection try: # x = str(len(frame.hands)) + "\n" # connection.sendall(x.encode('ascii')) for hand in frame.hands: handType = "Left Hand" if hand.is_left else "Right Hand" normal = hand.palm_normal direction = hand.direction pitch = direction.pitch * Leap.RAD_TO_DEG # Rotation around x-axis roll = normal.roll * Leap.RAD_TO_DEG # Rotation around z-axis yaw = direction.yaw * Leap.RAD_TO_DEG # Rotation around y-axis(Perpendicular to the plane) if pitch > 35: connection.sendall((handType + ",Back\n").encode('ascii')) elif pitch < -35: connection.sendall((handType + ",Front\n").encode('ascii')) for tool in frame.tools: connection.sendall(("Tool\n").encode('ascii')) for gesture in frame.gestures(): # swipe gesture if gesture.type == Leap.Gesture.TYPE_SWIPE: swipe = Leap.SwipeGesture(gesture) swipe_id = swipe.id swipe_state = self.state_names[gesture.state] swipe_position = swipe.position swipe_direction = swipe.direction swipe_speed = swipe.speed if swipe_direction.x > 0: connection.sendall(("Swipe Right\n").encode('ascii')) else: connection.sendall(("Swipe Left\n").encode('ascii')) # screen tab gesture elif gesture.type == Leap.Gesture.TYPE_SCREEN_TAP: screentap = Leap.ScreenTapGesture(gesture) screentap_id = gesture.id screentap_state = self.state_names[gesture.state] screentap_position = screentap.position screentap_direction = screentap.direction connection.sendall(("Screentab\n").encode('ascii')) # keytab Gesture elif gesture.type == Leap.Gesture.TYPE_KEY_TAP: keytap = Leap.KeyTapGesture(gesture) keytap_id = gesture.id keytap_state = self.state_names[gesture.state] keytap_position = keytap.position keytap_direction = keytap.direction connection.sendall(("Keytab\n").encode('ascii')) except socket.error: create_connection()
def __process_gesture(self, gesture): current_time = time.time() if current_time < self.__last_gesture_time + self.__gesture_cooldown_duration: return # Swipes (including ones that are only in-progress) take precedence over taps. if gesture.type is Leap.Gesture.TYPE_SWIPE: if gesture.state is Leap.Gesture.STATE_STOP: swipe = Leap.SwipeGesture(gesture) for pointable in swipe.pointables: if not pointable.is_finger: continue finger = Leap.Finger(pointable) if finger.type is not Leap.Finger.TYPE_INDEX: continue swipe_offset = swipe.position - swipe.start_position planar_swipe_offset_length_squared = swipe_offset.x**2 + swipe_offset.y**2 if planar_swipe_offset_length_squared < self.__min_swipe_length**2: continue assert len(gesture.hands) == 1 gesturing_hand = gesture.hands[0] self.__gesturing_hand_id = gesturing_hand.id swipe_angle = math.atan2(swipe.direction.y, swipe.direction.x) tau = 2.0 * math.pi if (swipe_angle < 0.0): swipe_angle += tau assert 0.0 <= swipe_angle and swipe_angle <= tau # lerp the real number range [0,tau] onto the integer range [0,8] menu_index = int(round(8.0 * swipe_angle / tau)) if menu_index == 8: # wrap 8 to 0. menu_index = 0 handedness = "lefthand" if gesturing_hand.is_left else "righthand" activated_compass_direction_name = self.__compass_direction_name[ menu_index] gesture_name = handedness + ":" + activated_compass_direction_name #Log.record('swiped {0}\n{1}\n'.format(gesture_name, self.__compass_direction_image[menu_index])) if self.__call_upon_gesture != None: self.__call_upon_gesture(gesture_name) self.__last_gesture_time = current_time elif gesture.type is Leap.Gesture.TYPE_KEY_TAP: key_tap = Leap.KeyTapGesture(gesture) if key_tap.pointable.is_finger: assert len(gesture.hands) == 1 gesturing_hand = gesture.hands[0] self.__gesturing_hand_id = gesturing_hand.id finger = Leap.Finger(key_tap.pointable) handedness = "lefthand" if gesturing_hand.is_left else "righthand" tap_name = "T-" + self.__finger_names[finger.type] gesture_name = handedness + ":" + tap_name #Log.record('tapped {0}\n'.format(gesture_name)) if self.__call_upon_gesture != None: self.__call_upon_gesture(gesture_name) self.__last_gesture_time = current_time
def on_frame(self, controller): frame = controller.frame() hands = frame.hands if DEBUG: print "Frame id: %d, timestamp: %d, hands: %d, fingers: %d" % \ (frame.id, frame.timestamp, len(frame.hands), len(frame.fingers)) hand = hands[0] # first hand print(hand.palm_position) if hands.is_empty: if DEBUG: print "no hands. Raspimouse should be stopped." self.stop() else: self.move() for gesture in frame.gestures(): # start to move by <Key Taps> # https://developer-archive.leapmotion.com/documentation/v2/python/api/Leap.KeyTapGesture.html if gesture.type is Leap.Gesture.TYPE_KEY_TAP: key_tap = Leap.KeyTapGesture(gesture) if DEBUG: print "keytap detected. Raspimouse will start to move." self.goForward() # Turn Left/Right <Swipe> # https://developer-archive.leapmotion.com/documentation/v2/python/api/Leap.SwipeGesture.html if gesture.type is Leap.Gesture.TYPE_SWIPE: swipe = Leap.SwipeGesture(gesture) direction = swipe.direction if abs(direction[0]) > abs( direction[1]): # horizontal movement if direction[0] > 0: swipeDirection = "right" self.turnRight() else: swipeDirection = "left" self.turnLeft() else: # vertical movement, nothing to do swipeDirection = "ignore" if DEBUG: print direction print swipeDirection print "Swipe gesture detected"
def on_frame(self, controller): global InitXPos global FinalXPos frame = controller.frame() for gesture in frame.gestures(): if gesture.type is Leap.Gesture.TYPE_CIRCLE: circle = Leap.CircleGesture(gesture) if circle.state == 3: ShapePos = 1 SHAPE.ShapeClassMenu(shapecircle, ShapePos) for gesture in frame.gestures(): if gesture.type is Leap.Gesture.TYPE_SWIPE: swipe = Leap.SwipeGesture(gesture) if swipe.state == 1: InitXPos = swipe.direction if swipe.state == 3: FinalXPos = swipe.direction DeltaX = float(FinalXPos[0]) - float(InitXPos[0]) if DeltaX < 0: if self.CurrentPos >= 1: self.CurrentPos = self.CurrentPos - 1 else: self.CurrentPos = 0 else: if self.CurrentPos <= 10: self.CurrentPos = self.CurrentPos + 1 else: self.CurrentPos = 11 state.LeapControl(self.CurrentPos) for gesture in frame.gestures(): if gesture.type is Leap.Gesture.TYPE_KEY_TAP: tap = Leap.KeyTapGesture(gesture) state.Reset() self.CurrentPos = 0
def on_frame(self, controller): # Get the most recent frame and report some basic information frame = controller.frame() for gesture in frame.gestures(): if gesture.type is Leap.Gesture.TYPE_KEY_TAP: key_tap = Leap.KeyTapGesture(gesture) printedid = [] for hand in key_tap.hands: handType = "Left hand" if hand.is_left else "Right hand" if (hand.id not in printedid): print " %s, position: %s" % (handType, hand.palm_position[0]) self.convertedkey = int( (hand.palm_position[0] + 200) / 400 * 16) if (self.convertedkey > 15): self.convertedkey = 15 if (self.convertedkey < 0): self.convertedkey = 0 print self.convertedkey printedid.append(hand.id)
def on_frame(self, controller): """ Get the most recent frame and report some basic information """ finger_angles = [ 'ThumbIndexAngle', 'IndexMidAngle', 'MidRingAngle', 'RingPinkyAngle' ] bone_angles = ['MetaProxAngle', 'ProxInterAngle', 'InterDistAngle'] bone_direc = [ 'MetaDirection', 'ProxDirection', 'InterDirection', 'DistDirection' ] bone_len = ['MetaLength', 'ProxLength', 'InterLength', 'DistLength'] bone_prevJoint = [ 'MetaPrevJoint', 'ProxPrevJoint', 'InterPrevJoint', 'DistPrevJoint' ] bone_nextJoint = [ 'MetaNextJoint', 'ProxNextJoint', 'InterNextJoint', 'DistNextJoint' ] frame = controller.frame() mydict = defaultdict(list) hand_num = len(frame.hands) for hand in frame.hands: arm = hand.arm mydict['ArmDirection'].append(str(arm.direction)[1:-1]) mydict['ElbowPosition'].append(str(arm.elbow_position)[1:-1]) mydict['ArmWidth'].append(str(arm.width)) mydict['WristPosition'].append(str(arm.wrist_position)[1:-1]) displacement = arm.wrist_position - arm.elbow_position mydict['ArmLength'].append(str(displacement.magnitude)) mydict['HandID'].append(str(hand.id)) mydict['HandConfid'].append(str(hand.confidence)) mydict['GrabStrength'].append(str(hand.grab_strength)) mydict['PalmNormal'].append(str(hand.palm_normal)[1:-1]) mydict['PalmYaw'].append(str(hand.direction.yaw)) mydict['PalmRoll'].append(str(hand.direction.roll)) mydict['PalmPitch'].append(str(hand.direction.pitch)) mydict['PalmPosition'].append(str(hand.palm_position)[1:-1]) mydict['HandDirection'].append(str(hand.direction)[1:-1]) mydict['PalmVelocity'].append(str(hand.palm_velocity)[1:-1]) mydict['PinchStrength'].append(str(hand.pinch_strength)) mydict['SphereCenter'].append(str(hand.sphere_center)[1:-1]) mydict['SphereRadius'].append(str(hand.sphere_radius)) mydict['PalmWidth'].append(str(hand.palm_width)) if hand.is_left: mydict['HandType'].append('Left hand') else: mydict['HandType'].append('Right hand') # Get fingers # finger_num = 5 * hand_num prox_direc = [] for finger in hand.fingers: prox_direc.append(finger.bone(1).direction) mydict['FingerType'].append(self.finger_names[finger.type]) mydict['FingerLength'].append(str(finger.length)) mydict['FingerWidth'].append(str(finger.width)) mydict['TipDirection'].append(str(finger.direction)[1:-1]) mydict['TipPosition'].append(str(finger.tip_position)[1:-1]) for ix, (d, l, p, n) in enumerate( zip(bone_direc, bone_len, bone_prevJoint, bone_nextJoint)): mydict[d].append(str(finger.bone(ix).direction)[1:-1]) mydict[l].append(str(finger.bone(ix).length)) mydict[p].append(str(finger.bone(ix).prev_joint)[1:-1]) mydict[n].append(str(finger.bone(ix).next_joint)[1:-1]) for ix, name in enumerate(bone_angles): angle = finger.bone(ix).direction.angle_to( finger.bone(ix + 1).direction) mydict[name].append(str(angle * 180 / Leap.PI)) for index, angle in enumerate(finger_angles): mydict[angle].append( str(prox_direc[index].angle_to(prox_direc[index + 1]) * 180 / Leap.PI)) # Get tools tool_num = len(frame.tools) for tool in frame.tools: mydict['ToolPosition'].append(str(tool.tip_position)[1:-1]) mydict['ToolDirection'].append(str(tool.direction)[1:-1]) # Get gestures gesture_num = len(frame.gestures()) for gesture in frame.gestures(): mydict['GestureState'].append(str(self.state_names[gesture.state])) mydict['GestureDuration'].append(str(gesture.duration)) if gesture.type == Leap.Gesture.TYPE_CIRCLE: #circle = Leap.CircleGesture(gesture) mydict['GestureType'].append('circle') #circle has no position attribute mydict['GesturePosition'].append(str([-1.0, -1.0, -1.0])[1:-1]) if gesture.type == Leap.Gesture.TYPE_SWIPE: mydict['GestureType'].append('swip') swipe = Leap.SwipeGesture(gesture) mydict['GesturePosition'].append(str(swipe.position)[1:-1]) if gesture.type == Leap.Gesture.TYPE_KEY_TAP: mydict['GestureType'].append('key tap') keytap = Leap.KeyTapGesture(gesture) mydict['GesturePosition'].append(str(keytap.position)[1:-1]) if gesture.type == Leap.Gesture.TYPE_SCREEN_TAP: mydict['GestureType'].append('screen tap') screentap = Leap.ScreenTapGesture(gesture) mydict['GesturePosition'].append(str(screentap.position)[1:-1]) # insert field length for multi-field values for _, value in mydict.iteritems(): value.insert(0, str(len(value))) # add sing field values mydict['GestureNum'].append(str(gesture_num)) mydict["LeapTime"].append(str(int(time.time() * 1000))) mydict['FrameID'].append(str(frame.id)) mydict['HandNum'].append(str(hand_num)) mydict['ToolNum'].append(str(tool_num)) self.vsocket.send_message(mydict) print 'frame rate: ', frame.current_frames_per_second mydict.clear()
def on_frame(self, controller): frame = controller.frame( ) # atribuindo a variavel frame o retorno de informações dos ultimos qudros captadas pelo leap motion #frame_penultimo_gesto = controller.frame(1) # atribuindo a variavel frame_penultimo_gesto o retorno de informações do penultimo gesto for hand in frame.hands: for gesture in frame.gestures(): #cada gesto tem seu ID criado if gesture.type == Leap.Gesture.TYPE_CIRCLE: circle = CircleGesture(gesture) #instanciando o objeto da classe gesto circulo # aqui o movimento circular é o de rotacionar o dedo na frente do computador if circle.pointable.direction.angle_to( circle.normal) <= Leap.PI / 2: clockwiseness = "clockwise" # indica que o circulo esta em sentido horario else: clockwiseness = "counter-clockwise" #indica que o circulo esta em sentido anti #swept angle vai dizer o qual longe vc foi no circulo desde a ultimo circulo identificado swept_angle = 0 if circle.state != Leap.Gesture.STATE_START: previous = CircleGesture( controller.frame(1).gesture(circle.id) ) #criando um novo frame ao escrever frame(1) swept_angle = (circle.progress - previous.progress) * 2 * Leap.PI # imprime no console o tamanho do circulo que voê gesticula e o sentido horario ou anti-horario caneta.pensize(2) caneta.circle(circle.radius) print "Radius: " + str(circle.radius) + " " + clockwiseness if gesture.type == Leap.Gesture.TYPE_SWIPE: #instanciando o objeto da classe gesto swipe swipe = SwipeGesture(gesture) #instnciando o objet da classe gesto da direção do swipe swipeDir = swipe.direction #criações das condições dos prints de acordo com as cordenadas estabelecidas pelo leap if ( swipeDir.x > 0 and math.fabs(swipeDir.x) > math.fabs(swipeDir.y) ): #se a posição da mão nas cordenas do leap for x>0, o seja mão indo para a direita print 'Swiped right' #(parte do and):também precisa priorisara leitura do movimento em x para facilitar a leitura do leap caneta.seth(0) caneta.ht() caneta.fd(10) elif ( swipeDir.x < 0 and math.fabs(swipeDir.x) > math.fabs(swipeDir.y) ): #se a posiçao da mão nas coodernadas do Leap x<0, ou seja, mão indo para esquerda print 'Swiped left' #(parte do and):também precisa priorisara leitura do movimento em x para facilitar a leitura do leap caneta.seth(180) caneta.ht() caneta.fd(10) elif ( swipeDir.y > 0 and math.fabs(swipeDir.x) < math.fabs(swipeDir.y) ): #se a posiçao da mão nas coodernadas do Leap y>0, ou seja, mão indo para cima print 'Swiped up' #(parte do and):também precisa priorisara leitura do movimento em y para facilitar a leitura do leap caneta.seth(90) caneta.ht() caneta.fd(10) elif ( swipeDir.y < 0 and math.fabs(swipeDir.x) < math.fabs(swipeDir.y) ): #se a posiçao da mão nas coodernadas do Leap x<0, ou seja, mão indo para baixo print 'Swiped down' #(parte do and):também precisa priorisara leitura do movimento em y para facilitar a leitura do leap caneta.seth(270) caneta.ht() caneta.fd(10) if gesture.type == Leap.Gesture.TYPE_KEY_TAP: #gesto de pinça key_tap = Leap.KeyTapGesture(gesture) tap_point = key_tap.position tapper = key_tap.pointable caneta.pd() print('caneta down') if gesture.type == Leap.Gesture.TYPE_SCREEN_TAP: #gesto de touch na tela screen_tap = Leap.ScreenTapGesture(gesture) caneta.pu() print('caneta up')
def on_frame(self, controller): #print "Frame available" frame = controller.frame() if not frame.is_valid: self.__ca.invalidatePointer() # TODO Maybe not? return #print "Frame id: %d, timestamp: %d, hands: %d, fingers: %d, tools: %d, gestures: %d" % ( # frame.id, frame.timestamp, len(frame.hands), len(frame.fingers), len(frame.tools), len(frame.gestures())) if len(frame.hands ) != 1: # User can only point into the cube with 1 hand self.__ca.invalidatePointer() # Is image stabilised? for hand in frame.hands: if hand.time_visible < self.MIN_TIME_VISIBLE: #TODO: What are the time units? seconds? self.__ca.invalidatePointer() return # If we're grabbing, rotate the scene: # We're grabbing -> rotate: if self.__weReGrabbing(frame): # Get overall frame rotation: # Get latest valid frame: for i in range(self.SEARCH_WINDOW, 0, -1): start_frame = controller.frame(i) if start_frame.is_valid: break windowDistance = self.SEARCH_WINDOW - i if windowDistance < self.MIN_WINDOW_SIZE: return # Window too short #windowFactor = self.SEARCH_WINDOW / windowDistance if not start_frame.is_valid: return if not self.__weReGrabbing(start_frame): return # We have to be grabbing on both frames to rotate # If the probability that user wanted to rotate is sufficient: #if frame.rotation_probability(start_frame) > 0.1: rotX = self.__cropRot( frame.rotation_angle(start_frame, Vector.x_axis) * self.FACTOR_ROTX) rotY = self.__cropRot( frame.rotation_angle(start_frame, Vector.y_axis) * self.FACTOR_ROTY) rotZ = self.__cropRot( frame.rotation_angle(start_frame, Vector.z_axis) * self.FACTOR_ROTZ) #dbg("Adding Rotation: " + str(-rotY) + ", " + str(-rotX) + ", " + str(rotZ)) # TODO: modify by some factor self.__ca.addRotation(-rotY, -rotX, rotZ) self.__ca.invalidatePointer() else: # We're not grabbing: # If there is only 1 hand # Was there a gesture in the frame? if len(frame.gestures()) == 1: for g in frame.gestures(): if g.is_valid and g.type is Leap.Gesture.TYPE_KEY_TAP: key_tap = Leap.KeyTapGesture(g) if (key_tap.pointable == frame.hands[0].fingers[1] and key_tap.direction.y < -0.8): self.__ca.announcePlacement( ) # Announce placement request to CA # TODO: delete after debugging: keyTap = Leap.KeyTapGesture(g) tap_point = keyTap.position tapPointStr = "(" + str( tap_point.x) + ", " + str( tap_point.y) + ", " + str( tap_point.z) + ")" tap_direction = keyTap.direction tapDirStr = "(" + str( tap_direction.x) + ", " + str( tap_direction.y) + ", " + str( tap_direction.z) + ")" dbg("Detected key tap gesture at " + tapPointStr + " with direction " + tapDirStr) # Update pointer if (len(frame.hands) == 1): #ptrPos = frame.hands[0].stabilized_palm_position ptrPos = frame.hands[0].palm_position px = ptrPos.x * self.POS_X_SCALE + self.POS_X_LINEAR py = ptrPos.y * self.POS_Y_SCALE + self.POS_Y_LINEAR pz = ptrPos.z * self.POS_Z_SCALE + self.POS_Z_LINEAR #dbg("Palm position update: " + str(px) + ", " + str(pz) + ", " + str(py)) self.__ca.updatePointer( px, pz, py ) #TODO: devide by some factor to fit Panda's coordinates
def on_frame(self, controller): left_bound = -50 right_bound = 50 up_bound = 360 down_bound = 220 back_bound = 120 forward_bound = -50 frame = controller.frame() hand = frame.hands.rightmost position = hand.palm_position velocity = hand.palm_velocity direction = hand.direction controller.enable_gesture(Leap.Gesture.TYPE_KEY_TAP) controller.enable_gesture(Leap.Gesture.TYPE_CIRCLE) #Key-tap gesture for gesture in frame.gestures(): if gesture.type is Leap.Gesture.TYPE_KEY_TAP: key_tap = Leap.KeyTapGesture(gesture) print("Turning drone on") if gesture.type is Leap.Gesture.TYPE_CIRCLE: circle = Leap.CircleGesture(gesture) print("Turning off") for hand in frame.hands: handType = "Left hand" if hand.is_left else "Right hand" #print " %s, id %d, position: %s" % ( # handType, hand.id, hand.palm_position) # print hand.palm_position #center point (0,200,0) #x-axis if (hand.palm_position[0] < left_bound): print("Moving left") elif (hand.palm_position[0] > right_bound): print("Moving right") #y-axis if (hand.palm_position[1] > up_bound): print("Moving up") elif (hand.palm_position[1] < down_bound): print("Moving down") #z-axis if (hand.palm_position[2] > back_bound): print("Moving back") elif (hand.palm_position[2] < forward_bound): print("Moving forward") if (hand.palm_position[0] > left_bound) and (hand.palm_position[0] < right_bound) and ( hand.palm_position[1] < up_bound) and ( hand.palm_position[1] > down_bound) and ( hand.palm_position[2] < back_bound) and ( hand.palm_position[2] > forward_bound): print "Not moving"
def on_frame(self, controller): global direccion_media, posicion_media, tutorial_activo_leap, tutorial_iniciado_leap, inicio_tutorial, tiempo_baqueta_tutorial, string_sonidos global cambiosonido_iniciado, inicio_cambiosonido, tiempo_cambiosonido, num_instrumento global hubo_gesto # Tomamos un frame frame = controller.frame() # Obtenemos la posicion y la direccion de la baqueta(s) for tool in frame.tools: posicion_media.append(tool.tip_position) direccion_media.append(tool.direction) if not tutorial_activo_leap: # Comprobamos los gestos for gesture in frame.gestures(): # Key tap (gesto similar al de pulsar una tecla) if gesture.type == Leap.Gesture.TYPE_KEY_TAP: keytap = Leap.KeyTapGesture(gesture) pos = keytap.position hubo_gesto = True tolerancia = 1.5 if self.DEBUG: print "pos = ", pos, # Dependiendo de la región, reproducimos un sonido u otro if -graficos.desplazamiento_bateria <= pos[ 0] <= -graficos.comienzo_bateria and -graficos.desplazamiento_bateria <= pos[ 2] <= -graficos.comienzo_bateria: if self.DEBUG: print "Sonido 0" self.sonidos[0].play() if graficos.comienzo_bateria <= pos[ 0] <= graficos.desplazamiento_bateria and -graficos.desplazamiento_bateria <= pos[ 2] <= -graficos.comienzo_bateria: if self.DEBUG: print "Sonido 1" self.sonidos[1].play() if -graficos.desplazamiento_bateria <= pos[ 0] <= -graficos.comienzo_bateria and graficos.comienzo_bateria <= pos[ 2] <= graficos.desplazamiento_bateria: if self.DEBUG: print "Sonido 2" self.sonidos[2].play() if graficos.comienzo_bateria <= pos[ 0] <= graficos.desplazamiento_bateria and graficos.comienzo_bateria <= pos[ 2] <= graficos.desplazamiento_bateria: if self.DEBUG: print "Sonido 3" self.sonidos[3].play() if self.DEBUG: print " Key Tap id: %d, %s, position: %s, direction: %s" % ( gesture.id, self.state_names[gesture.state], keytap.position, keytap.direction) if gesture.type == Leap.Gesture.TYPE_SCREEN_TAP: graficos.menu_activo = not graficos.menu_activo # Lógica para hacer el gesto de reconocimiento if tutorial_activo_leap and posicion_media: if not tutorial_iniciado_leap: if graficos.comienzo_bateria <= posicion_media[0][ 0] <= graficos.desplazamiento_bateria and graficos.comienzo_bateria <= posicion_media[ 0][2] <= graficos.desplazamiento_bateria: tutorial_iniciado_leap = True inicio_tutorial = time.time() else: if time.time() - inicio_tutorial < tiempo_baqueta_tutorial: if not (graficos.comienzo_bateria <= posicion_media[0][0] <= graficos.desplazamiento_bateria and graficos.comienzo_bateria <= posicion_media[0][2] <= graficos.desplazamiento_bateria): tutorial_iniciado_leap = False else: tutorial_activo_leap = False # Lógica para cambiar el sonido de una región if not tutorial_activo_leap and posicion_media: if not cambiosonido_iniciado: if -graficos.desplazamiento_bateria <= posicion_media[0][ 0] <= -graficos.comienzo_bateria and -graficos.desplazamiento_bateria <= posicion_media[ 0][2] <= -graficos.comienzo_bateria: num_instrumento = 0 if graficos.comienzo_bateria <= posicion_media[0][ 0] <= graficos.desplazamiento_bateria and -graficos.desplazamiento_bateria <= posicion_media[ 0][2] <= -graficos.comienzo_bateria: num_instrumento = 1 if -graficos.desplazamiento_bateria <= posicion_media[0][ 0] <= -graficos.comienzo_bateria and graficos.comienzo_bateria <= posicion_media[ 0][2] <= graficos.desplazamiento_bateria: num_instrumento = 2 if graficos.comienzo_bateria <= posicion_media[0][ 0] <= graficos.desplazamiento_bateria and graficos.comienzo_bateria <= posicion_media[ 0][2] <= graficos.desplazamiento_bateria: num_instrumento = 3 if num_instrumento is not None: cambiosonido_iniciado = True inicio_cambiosonido = time.time() else: if hubo_gesto: cambiosonido_iniciado = False elif time.time() - inicio_cambiosonido < tiempo_cambiosonido: if num_instrumento == 0: if not (-graficos.desplazamiento_bateria <= posicion_media[0][0] <= -graficos.comienzo_bateria and -graficos.desplazamiento_bateria <= posicion_media[0][2] <= -graficos.comienzo_bateria): cambiosonido_iniciado = False elif num_instrumento == 1: if not (graficos.comienzo_bateria <= posicion_media[0] [0] <= graficos.desplazamiento_bateria and -graficos.desplazamiento_bateria <= posicion_media[0][2] <= -graficos.comienzo_bateria): cambiosonido_iniciado = False elif num_instrumento == 2: if not (-graficos.desplazamiento_bateria <= posicion_media[0][0] <= -graficos.comienzo_bateria and graficos.comienzo_bateria <= posicion_media[0][2] <= graficos.desplazamiento_bateria): cambiosonido_iniciado = False elif num_instrumento == 3: if not (graficos.comienzo_bateria <= posicion_media[0] [0] <= graficos.desplazamiento_bateria and graficos.comienzo_bateria <= posicion_media[0][2] <= graficos.desplazamiento_bateria): cambiosonido_iniciado = False else: string_sonidos[ num_instrumento] = logicamenu.cambio_instrumento( string_sonidos) self.sonidos = [ pygame.mixer.Sound("sonidos/" + s) for s in string_sonidos ] cambiosonido_iniciado = False # Si hay baquetas, redibujar if posicion_media: graficos.redibujar() # Quitar baquetas posicion_media = [] direccion_media = [] hubo_gesto = False
def on_frame(self, controller): global swipeLeft global swipeRight global fistTimer global turnDir global swipeDir global swipeFinger global tapFinger global screenTapFinger global pinch global grab global fingerCount # Get the most recent frame and report some basic information frame = controller.frame() turns = 0 #Configurating Gesture Settings controller.config.set("Gesture.Swipe.MinLength", 220) controller.config.set("Gesture.Swipe.MinVelocity", 100) controller.config.save() controller.config.set("Gesture.KeyTap.MinDownVelocity", 40.0) controller.config.set("Gesture.KeyTap.HistorySeconds", .3) controller.config.set("Gesture.KeyTap.MinDistance", 1.0) controller.config.save() controller.config.set("Gesture.ScreenTap.MinForwardVelocity", 20.0) controller.config.set("Gesture.ScreenTap.HistorySeconds", .5) controller.config.set("Gesture.ScreenTap.MinDistance", 1.0) controller.config.save() for gesture in frame.gestures(): #Circle Gesture if gesture.type == Leap.Gesture.TYPE_CIRCLE: circle = CircleGesture(gesture) if (circle.pointable.direction.angle_to(circle.normal) <= Leap.PI / 2): turnDir = "CW" turns += circle.progress if (turns > 2.5): pyautogui.hotkey('volumeup') #sleep(.1) else: turnDir = "CCW" turns -= circle.progress if (turns < -2.5): pyautogui.hotkey('volumedown') #sleep(.1) print(turnDir + " " + str(turns)) ######SWAP WITH FUCNTION #Swipe Gesture if gesture.type is Leap.Gesture.TYPE_SWIPE: swipe = Leap.SwipeGesture(gesture) swipeDir = swipe.direction swipeFinger = swipe.pointable if (swipeDir[0] < 0): pyautogui.moveTo(980, 540, 0) pyautogui.click() pyautogui.hotkey('left') pyautogui.hotkey('alt', 'tab') sleep(1.2) elif (swipeDir[0] > 0): pyautogui.moveTo(980, 540, 0) pyautogui.click() pyautogui.hotkey('right') pyautogui.hotkey('alt', 'tab') sleep(1.2) print("Swipe " + str(swipeFinger) + " " + str(swipeDir[0]) ) ######SWAP WITH FUCNTION #Key-Tap Gesture if gesture.type is Leap.Gesture.TYPE_KEY_TAP: tap = Leap.KeyTapGesture(gesture) tapFinger = tap.pointable tapDir = tap.direction print("Tap " + str(tapDir)) ######SWAP WITH FUCNTION #Screen-Tap Gesture if gesture.type is Leap.Gesture.TYPE_SCREEN_TAP: screenTap = Leap.ScreenTapGesture(gesture) screenTapFinger = screenTap.pointable print("ScreenTap " + str(screenTapFinger) ) ######SWAP WITH FUCNTION for hand in frame.hands: #Identifies the hand handType = "Left" if hand.is_left else "Right" grab = hand.grab_strength pinch = hand.pinch_strength #print(handType + " p:" + str(pinch) + " g:"+ str(grab)) ######SWAP WITH FUCNTION if grab == 1: if (fistTimer > 2): pyautogui.hotkey('volumemute') print("g" + str(grab)) sleep(1.2) fistTimer = 0 else: fistTimer += 1 '''elif pinch > 0.99: