comparison tim_grid_mapper/grid_mapper.py @ 3:7bd1f07044ab

Added grid_mapper to map from Kinect data to Joe's synth and Ableton.

Added OSC.py which is a library file. You need it to run grid_mapper.py but please don't change it.

+'''
+grid_mapper.py - maintained by Tim.
+
+This module implements a mapping from person positions (id,x,y,z) to generate 
+pitch, velocities and channels for Joe's synthesiser and controller data for
+Ableton.
+
+'''
+
+from OSC import ThreadingOSCServer, OSCClient, OSCMessage, OSCClientError
+
+#### PUBLIC OPTIONS ####
+num_instruments = 3 # number of output channels
+
+#### OSC OPTIONS - THESE NEED TO BE SET MANUALLY ####
+my_port = 2001 # to receive OSC messages
+joe     = ('localhost', " PUT JOE's PORT NUMBER IN HERE")
+ableton = ('localhost', " PUT ABLETON'S PORT NUMBER IN HERE ")
+
+### Constants for grid mapping:
+# The range of values that the input coordinates and output values may take:
+# (ranges are inclusive)
+MIN = {
+	'x'		: 0.,
+	'y'		: 0.,
+	'z'		: 0.,
+	'pitch'	: 0,
+	'cc1'   : 0,
+	'cc2'   : 0,
+}
+MAX = {
+	'x'     : 1.,
+	'y'     : 1.,
+	'z'     : 1.,
+	'pitch' : 15,
+	'cc1'   : 127,
+	'cc2'   : 127,
+}
+
+
+
+#### PRIVATE VARIABLES ####
+person_positions  = {} # mapping from personId to x,y,z
+last_update_times = {} # mapping from personId to time of last update
+
+# OSC OBJECTS
+server = ThreadingOSCServer(('localhost'), my_port)
+client = OSCClient()
+
+
+def send_to_joe(data, address='/test'):
+	'''Sends `data` to Joe directly as an OSC message.
+	'''
+	message = OSCMesssage(address)
+	message.extend(data)
+	client.sendto(message, joe)
+
+
+
+def person_handler(address, tags, data, client_address):
+	''' Handles OSC input matching the 'person' tag.
+	
+	`data` is [person_id, x, y, z]
+	'''
+	pitch, velocity, channel, cc1, cc2 = grid_map(data)
+	
+	## Format data for Joe - done using Specification.txt on 2011-02-15
+	
+	# constrain and round off pitch and velocity
+	pitch = max(min(round(pitch), MAX['pitch']), MIN['pitch'])
+	velocity = max(min(round(pitch), MAX['velocity']), MIN['velocity'])
+	
+	# turn integer pitch into a single 1 in a boolean array of 0s
+	boolean_note_array = [0] * (MAX['pitch'] - MIN['pitch'] + 1)
+	boolean_note_array[pitch] = 1
+	
+	# seperate boolean for note-on and note-off
+	note_on = velocity > 0
+	# Never send velocity == 0
+	if velocity==0: 
+		velocity = 127
+	THIS NEEDS FINISHING.
+	
+
+
+
+def grid_map(person_id, x, y, z):
+	'''This function maps from a person's location to MIDI data
+	returning a tuple (pitch, velocity, channel, cc1, cc2).
+	
+	The current mapping creates higher pitch values as the person moves
+	closer to the Kinect (i.e. z decreases). x and y values are mapped to cc1 
+	and cc2 (to be sent straight to Ableton and determined by a particular
+	synth)
+	
+	NB. channel == person_id and velocity==0 when note is off.
+	Midi-Velocity is currently unimplemented but will use Person-velocity data
+	when that becomes available.
+	This function does not guarantee that the output will be in range if the 
+	input goes out of range.
+	'''
+	pitch = round(interpolate(z, 
+	                          MIN['z'],     MAX['z'],
+	                          MIN['pitch'], MAX['pitch'])
+	        )
+	cc1 = round(interpolate(x, 
+	                          MIN['x'],     MAX['x'],
+	                          MIN['cc1'], MAX['cc1'])
+	        )
+	cc2 = round(interpolate(x, 
+	                          MIN['y'],     MAX['y'],
+	                          MIN['cc2'], MAX['cc2'])
+	        )
+	velocity = 127
+	return (pitch, velocity, person_id, cc1, cc2)
+	
+
+
+
+def interpolate(x, a, b, A, B):
+	''' Interpolates x from the range [a, b] to the range [A, B].
+	
+	
+	Interpolation is linear. From [a,b] to [A,B] this would be:
+	(B-A)*(x-a)/(b-a) + A
+	'''
+	return (B-A)*(x-a)/(b-a) + A