FxME - interaktive Audiomanipulationen

Aus toolbox_interaktion
Wechseln zu: Navigation, Suche

Die Grundidee dieses Interaktion Projektes ist es, Audiosignale mit Hilfe von Bewegungen zu manipulieren und zu steuern. Dabei steht vor allem der interaktive Grundgedanke im Vordergrund, welcher auf spielerische Art und Weise dem Anwender den Umgang mit Audiosoftware ermöglichen soll und zudem die Hardwareabhängigkeit vermindern soll. Um die Steuerung zu erleichtern, bekommt der Anwender ein visuelles Feedback in Form einer Benutzeroberfläche, auf der er selbst dargestellt ist, um somit die Auswirkungen seiner Bewegungen besser verstehen und interpretieren zu können. Die möglichen Anwendungsgebiete liegen im Bereich der Präsentationstechnik sowie der Liveperformance.


Hardware

Überblick

Zur technischen Realisierung ist eine digitale Kamera notwendig, die eine Sensorik beinhaltet, welche Bewegungen des Körpers analysieren und interpretieren kann. Diese Informationen sollen dann (über eine universelle Schnittstelle, z.B. USB oder Firewire) an einen Computer weitergegeben werden, der dann die Daten weiterverarbeitet. Um die Bedienbarkeit zu verbessern, wird ein Tablet-PC (hier: iPad) verwendet. Zur Kommunikation der verschiedenen Hardwarekomponenten wird ein WLAN/LAN-Router eingesetzt.
Grafik001 Aufbau.jpg

Lösung

Im folgenden Abschnitt wird genauer beschrieben welche speziellen Hardwarekomponenten verwendet wurden.

Microsoft Kinect

Bei der Wahl der Kamera fiel die Entscheidung auf die Microsoft Kinect, da sie folgende Vorteile bietet: - Einfacher Anschluss via USB-Schnittstelle - Übertragung eines RGB-Bildes - Erfassung der Tiefeninformationen - Ausgabe der Skelettdaten (mit Hilfe passender Libraries) - gutes Preis/Leistungsverhältnis - große Community - sehr flexible, umfangreiche Programmiermöglichkeiten

Rechner

Um die eingehenden Signale weiterzuverarbeiten, wird ein Computer benötigt, auf dem die unter 3. aufgeführte Software lauffähig ist. In diesem Projekt wurde ausschließlich mit OSX Betriebssystemen gearbeitet. Um die Signalverarbeitung, sowie den visuellen Teil vom auditiven Teil zu trennen, ist das System auf zwei Rechner aufgeteilt worden.

iPad

Um die interaktive Steuerung zu erhöhen, sollte - wenn möglich - gänzlich auf die Bedienung der Rechner verzichtet werden. Aus diesem Grund wird zur Steuerung der Audiosoftware ein Tablett-PC verwendet.

Netzwerktechnik

Damit die verschiedenen Geräte reibungslos miteinander kommunizieren können, wird mit einem Router ein kleines WLAN/LAN Netzwerk aufgebaut. Die beiden Rechner werden über LAN direkt an den Router angeschlossen, während der Tablett-PC über WLAN auf das Netzwerk zugreift.


Software

Überblick

Bei der Wahl der Softwarekomponenten ist man kaum eingeschränkt, da es viele verschiedene Möglichkeiten in diesem Bereich gibt. Die Wahl der passenden Software ist von vielen Faktoren abhängig, unter anderem z.B. vom verwendeten Betriebsystem.
Grafik002 software.jpg

Lösung

Im folgenden Abschnitt wird erklärt, welche Software in diesem Projekt verwendet wurde.


Processing

Processing ist eine Programmierumgebung, die auf Java basiert. Dadurch bestehen von programmiertechnischer Seite aus kaum Einschränkungen zur Realisierung verschiedener Projekte. Aufgrund der großen Community, die die Microsoft Kinect mit sich bringt, ist es sehr leicht möglich passende Bibliotheken in Processing zu integrieren, die dann die nötige Funktionalität zur Realisierung bereitstellen. Beispielsweise bietet die eine Library die Funktionalität, OSC-Signale zu senden, die andere hingegen, Skelettdaten aus der Kinect zu gewinnen.


OSC-Midi/OSCulator

Die aus Processing gewonnenen OSC-Signale müssen mit Hilfe einer Software in passende Midi-Signale umgewandelt werden, da die Audiosoftware nur mittels Midi-Signalen steuerbar ist. OSCulator stellt hier also die Schnittstelle zwischen OSC und Midi dar. Es empfängt alle auf den Computer eingehenden OSC-Signale und kann diese wiederum als Midi-Signale ausgeben. Dabei ist die Art, der Kanal und der Wertebereich des Midi-Signals frei wählbar.

Grafik003 osculator.png

Traktor

Mit Traktor wird eine weit verbreitete DJ Software verwendet, die sowohl direkt am PC, als auch über Midi-Geräte gesteuert werden kann. Hierfür bietet die Software einen sogenannten Midi-Mapper, in dem die einzelnen Midi-Signale verschiedenen Funktionalitäten zugeordnet werden können. Zur Audiomanipulation bietet Traktor verschiedene gängige Audio Effekte (Delay, Reverb, Filter, Echo, etc.), die ebenfalls mit Midi-Signalen steuerbar sind. Die Benutzeroberfläche ist sehr übersichtlich und relativ leicht bedienbar. Die Effektvielfalt und Effektkombination ist umfangreich.
Grafik004 traktormapping.png
Grafik005 effektetraktor.png


TouchOSC

TouchOSC ist eine Application die für Apple Produkte verfügbar ist. Mit diesem Programm lassen sich Benutzeroberflächen erstellen, die zur vielseitigen Steuerung unterschiedlichster Programme verwendet werden können. Um, wie erwähnt, die Computer nicht direkt steuern zu müssen, wird TouchOSC verwendet um mit dem iPad in Traktor zu navigieren. TouchOSC sendet ebenfalls OSC-Signale, die wiederum in OSCulator zu Midi-Signalen verarbeitet werden und dann in Traktor Verwendung finden.
Grafik006 touchosc.png


Libraries

Um den Funktionsumfang von Processing zu erweitern, werden verschiedene Libraries benötigt. Die wichtigste Library ist die OpenNI Library. Diese gewährleistet die Kompatibilität zwischen Processing und der Microsoft Kinect. Weitere eingebundene Bibliotheken sind: openkinect, SimpleOpenNI und oscP5.


Programmierung

Processing

Um alle Komponenten miteinander zu verknüpfen, spielt der Programmcode eine fundamentale Rolle. Er stellt die Schnittstelle zwischen der Kinect und der DJ-Software her und übernimmt die Visualisierung des GUI (General User Interface). Es werden sowohl Tiefeninformationen, als auch das RGB-Bild der Kinect abgegriffen. Letzteres ist für das Interface von zentraler Bedeutung. Die Weiterleitung der OSC-Signale wird ebenfalls über die Programmierung realisiert. Hier ein paar wichtige Auszüge des Programmcodes mit anschließender Erläuterung.


Setup

import SimpleOpenNI.*; import oscP5.*; import netP5.*;

In den ersten drei Zeilen des Codes werden die Libraries eingebunden.

void setup() { context = new SimpleOpenNI(this);

context.setMirror(true); context.enableDepth(); context.enableRGB(); context.enableUser(SimpleOpenNI.SKEL_PROFILE_ALL);

Hier wird das RGB-Bild der Kinect abgegriffen und die Tiefeninformationen werden zur Initialisierung des Skelletmodells verwendet.

oscP5 = new OscP5(this,12000); myRemoteLocation = new NetAddress("192.168.1.101",8000); 

Die OSC-Signale werden über das Netzwerk (IP: 192.168.1.101:8000) übertragen.


Tracking

void setup() { context.enableUser(SimpleOpenNI.SKEL_PROFILE_ALL); }

void draw() { if(context.isTrackingSkeleton(1)) drawLinkeHand(1); drawRechteHand(1); sendOSCeleton(1); } 

Der User wird getrackt und die Partikel Systeme werden auf die Handflächen gezeichnet.

void drawLinkeHand(int userId)

PVector PositionLeftHand = new PVector(); context.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_LEFT_HAND, Position);

PVector BildPosition = new PVector(); context.convertRealWorldToProjective(Position, BildPosition);

Position der linken Hand wird erkannt.

PVector POSHIP = new PVector(); context.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_LEFT_HIP, POSHIP);

PVector BildPositionHip = new PVector(); context.convertRealWorldToProjective(POSHIP, 
BildPositionHip);

Position der Hüfte wird erkannt.

oscOutLeftX(BildPosition.x); oscOutLeftY(BildPosition.y, BildPositionHip.y); 
valueLeftY = convertPercentageLeftY(BildPosition.y, BildPositionHip.y); } 

Übertragung der Y-Koordinate der linken Hand in Abhängigkeit der Hüfte.


OSC-Signale

void oscOutLeftY(float pos, float posHipY) { OscMessage myMessage = new OscMessage("oscOutLeftY");

pos = - ((pos - poshipy )/context.rgbHeight()); if(pos <= 0){pos = 0;}

myMessage.add(pos); oscP5.send(myMessage, myRemoteLocation); } 

Es wird ein OSC-Signal mit einem numerischen Wert zwischen 1 und 0 übertragen. OSCulator empfängt dieses Signal und verarbeitet es entsprechend weiter.


Partikel System

ParticleSystem particleRight; ParticleSystem particleLeft;

void setup() { particleRight = new ParticleSystem(new PVector(i,0)); particleLeft = new ParticleSystem(new PVector(i,0)); } 
//Instanz der Klasse ParticleSystem erstellen

particleRight.addParticle(valuePercentageRight); 
//einzelne "Particles" werden im "Particle-System" hinzugefügt 
particleRight.run(); 
particleLeft.addParticle(valuePercentageLeft); 
particleLeft.run(); 

Partikel werden gezeichnet

class ParticleSystem { ArrayList<Particle> particles; PVector origin;

ParticleSystem(PVector location) { origin = location.get(); particles = new ArrayList<Particle>(); }

void addParticle(int wert) {

for(float i=0; i<wert; i+=4) { particles.add(new Particle(origin));

} }

void run() { Iterator<Particle> it = particles.iterator(); while (it.hasNext()) 
{ Particle p = it.next(); p.run(); if (p.isDead()) { it.remove(); } } } }

class Particle { PVector location; PVector velocity; PVector acceleration; float lifespan;

Particle(PVector l) { acceleration = new PVector(0,0.1); velocity = new PVector(random(-1,1),random(-2,0)); 
location = l.get(); lifespan = 255.0; }

void run() { update(); display(); }

// Method to update location void update() { velocity.add(acceleration); location.add(velocity); lifespan -= 7; 
//Geschwindigkeit mit der die Partikel verschwinden }

// Method to display void display() {

Random rand = new Random(); int co1 = rand.nextInt(255); int co2 = rand.nextInt(255); int co7 = rand.nextInt(8); 
stroke(0,0,co1,lifespan); fill(0,0,co2,lifespan); ellipse(location.x,location.y,co7,co7); }

// Is the particle still useful? boolean isDead() { if (lifespan < 0.0) { return true; } else { return false; } } } 

Ergebnis/Resultat

Es ist in diesem Projekt gelungen, ein interaktives System aus Hardware und Software zu konzipieren, dieses anschließend zu realisieren und schließlich auch ausgiebig zu testen. Durch die erfolgreiche Integration des Tablet-PCs, ist die Bedienung des Rechners während des Betriebs nichtmehr notwendig und durch das visuelle Feedback aller nötigen Parameter wird auch der Blick auf den Monitor überflüssig. Das komplette interaktive Geschehen spielt sich also in unmittelbarer, intuitiver Umgebung des Benutzers ab. Der Benutzer bekommt so im Idealfall also gar nicht mit, was im Hintergrund abläuft und kann sich somit voll und ganz auf die interaktiven Audiomanipulationen konzentrieren.

Ausblick

Im Verlauf des Projektes und der damit verbundenen Recherche im Internet fand man immer wieder vergleichbare Projekte mit ähnlichen Grundgedanken und Inhalten. Das wohl überzeugendste und aufwendigste Projekt stellt hierbei das "V Motion Project" dar, bei dem nicht nur Audioeffekte, sondern auch verschiedene Audioamples und sogar Synthesizer über Körperbewegungen angesteuert werden können. Es lassen sich also Melodien oder theoretisch sogar ganze Kompositionen kreieren. Zusätzlich zur auditiven Komponente wurde ein aufwändiges User Interface mit vielen beeindruckenden Visualisierungen generiert.

Das Video (Link unten) entspricht in dieser Form sicher nicht ganz der Realität (zu perfektes Tracking, keine Latenz). Die Präsentation und das Making Of stellen letztendlich jedoch eine sehr gelungene Umsetzung der gemeinsamen Grundidee des "V Motion Projects" und diesem Projektes "fxMe" dar. Das Thema rund um die Audiomanipulation und Audiosteuerung wird auch in Zukunft weiterhin ein sehr attraktives Entwicklungs- und Forschungsgebiet der Interaktion darstellen, da das Potential hier sehr groß ist und noch lange nicht ausgeschöpft ist. In absehbarer Zeit kann man sich wohl also auch als Privatverbraucher auf viele neue interaktive Systeme rund um das Thema Audio freuen, die alle bisherigen Systeme revolutionieren werden.

http://vimeo.com/45417241

Downloads

Ausführbare Programme (Windows/OSX/Linux)

TouchOSC Layout für iPad