< 

Marek Slipek

 Bild: Bildfilter 
 Video: Lochmaske/Linienmuster 
 OSC Netzwerk: Sender/Empfänger/touchOSC 
 Audio: Pegel/Pegelglättung/Mikrofoneingang/Synthesizer 
 Mindwave: Gehirnwellen 
 LeapMotion: Virtuelle Leinwand 
 controlP5: Digitale Fader 
 Kinect: Freisteller/Punktwolke 
 Myo: Gestensteuerung 

Information und Kommunikation

Sammlung von Processing-Codebeispielen für verschiedenste Interfaces: Jedes der Beispiele umfasst nur das Notwendigste und ist als Gerüst für eigene Projekte gedacht. Für die Funktionsfähigkeit der Beispiele muss in der Regel eine externe Library in Processing eingebunden werden und das verwendete Gerät physisch an den Rechner angeschlossen sein. Die Sammlung umfasst folgende Themen: Bildfilter, Videofilter, OSC-Netzwerk, Mikrofoneingang, Audioplayer, Synthesizer, Mindwave, LeapMotion, controlP5, Kinect und Myo.

 


Bild

Bildfilter

PImage img;

void setup() {
size(800, 600);
img = loadImage(“80x60px.png“);
fill(0);
noStroke();
}

void draw() {
for (int x = 0; x < img.width; x = x + 1) {
for (int y = 0; y < img.height; y = y + 1) {
color c = img.pixels[y*img.width+x];
int graustufe = round(red(c)*0.222+green(c)*0.707+blue(c)*0.071);
float radius = map(graustufe, 0,255, 10,0);
int pixelabstand = 10;
ellipse (x*pixelabstand, y*pixelabstand, radius, radius);
}
}
}

 

 zurück zur Übersicht 


Video

Lochmaske

import processing.video.*;
int rX, rY, xypos;
Capture webcam;

void setup() {
size (1280, 720);
noStroke ();
String[] kameraliste = Capture.list();
webcam = new Capture(this, kameraliste[0]);
webcam.start();
}

void draw() {
background (0);
rX = 10; // rasterweite X
rY = 10; // rasterweite Y
if (webcam.available() == true) {
webcam.read();
webcam.loadPixels();
}
for (int x = 0; x < webcam.width; x = x + rX) {
for (int y = 0; y < webcam.height; y = y + rY) {
xypos = y*webcam.width + x; // Zeilen berechnen
color c = webcam.pixels[xypos];
fill (c);
rect (x, y, 2, 2);
}
}
}

Linienmuster

import processing.video.*;
int rX, rY, xypos;
Capture webcam;

void setup() {
size (1280, 720);
noStroke ();
String[] kameraliste = Capture.list();
webcam = new Capture(this, kameraliste[0]);
webcam.start();
}

void draw() {
background (0);
rX = 1; // rasterweite X
if (webcam.available() == true) {
webcam.read();
webcam.loadPixels();
}
int y = webcam.height/2;
for (int x = 0; x < webcam.width; x = x + rX) {
xypos = y*webcam.width + x; // Zeilen berechnen
color c = webcam.pixels[xypos];
stroke (c);
line (x, 0, x, webcam.height);
}
}

 

 zurück zur Übersicht 


OSC Netzwerk

Sender

import oscP5.*;
import netP5.*;
OscP5 meinComputer;
NetAddress zielComputer;
float posX = 0;
float posY = 0;

void setup() {
size(400,400);
meinComputer = new OscP5(this,8001);
zielComputer = new NetAddress("10.0.2.95",8000);
}

void draw() {
background(0);
ellipse (posX, posY, 40, 40);
posX = mouseX;
OscMessage xNachricht = new OscMessage("/x");
xNachricht.add(posX);
meinComputer.send(xNachricht, zielComputer);
posY = mouseY;
OscMessage yNachricht = new OscMessage("/y");
yNachricht.add(posY);
meinComputer.send(yNachricht, zielComputer);
}

Empfänger

import oscP5.*;
import netP5.*;
OscP5 meinComputer;
NetAddress zielComputer;
float posX = 0;
float posY = 0;

void setup() {
size(400,400);
meinComputer = new OscP5(this,8000);
zielComputer = new NetAddress("10.0.2.4",8001);
}

void draw() {
background(0);
rect (posX, posY, 40, 40);
}

void oscEvent(OscMessage Nachricht) {
print("OSC-Nachricht eingegangen.");
print("Nachrichtenname: " +
Nachricht.addrPattern());
if (Nachricht.checkAddrPattern("/x")) {
posX = Nachricht.get(0).floatValue();
println("X-Koordinate: " + posX);
}
if (Nachricht.checkAddrPattern("/y")) {
posY = Nachricht.get(0).floatValue();
println("Y-Koordinate: " + posY);
}
}

touchOSC

import oscP5.*;
import netP5.*;
OscP5 oscP5;
float breite = 0.5;
float hoehe = 0.5;

void setup() {
size(400,400);
frameRate(25);
// Port 8000 für eingehende Nachrichten
oscP5 = new OscP5(this,8000);
}

void oscEvent(OscMessage nachricht) {
String addr = nachricht.addrPattern();
float val = nachricht.get(0).floatValue();
if (addr.equals("/fader/breite")) breite = val;
if (addr.equals("/fader/hoehe")) hoehe = val;
}

void draw() {
background(0);
ellipse(width/2, height/2, breite*400, hoehe*400);
}

 

 zurück zur Übersicht 


Audio

Pegel

import processing.sound.*;
SoundFile song;
Amplitude pegel;
float durchmesser;

void setup() {
size (400, 400);
fill (255);
song = new SoundFile(this, "songmono.aiff");
song.loop();
pegel = new Amplitude(this);
pegel.input(song);
}

void draw() {
background (0);
durchmesser = pegel.analyze(); // 0 bis 1
durchmesser = durchmesser * 600; // Skalieren
ellipse (width/2, height/2,
durchmesser, durchmesser);
}

Pegelglättung

import processing.sound.*;
SoundFile song;
Amplitude pegel;
float durchmesser, signal, summe;

void setup() {
size (400, 400);
fill (255);
song = new SoundFile(this, "songmono.aiff");
song.loop();
pegel = new Amplitude(this);
pegel.input(song);
}

void draw() {
background (0);
signal = pegel.analyze(); // Wert 0 bis 1
summe = summe + (signal - summe) * 0.25;
// Signalglättung 0.1 bis 1
durchmesser = summe * 600; // Wert skalieren
ellipse (width/2, height/2, durchmesser, durchmesser);
}

Mikrofoneingang

import processing.sound.*;
AudioIn mikrofon;
Amplitude pegel;
float durchmesser;

void setup() {
size (400, 400);
// Eingangskanal 0
mikrofon = new AudioIn(this, 0);
mikrofon.start();
pegel = new Amplitude(this);
pegel.input(mikrofon);
}

void draw() {
background (0);
fill (255);
mikrofon.amp(1); // Eingangstärke 0 bis 1
durchmesser = pegel.analyze(); // 0 bis 1
durchmesser = durchmesser * 350;
ellipse (width/2, height/2,
durchmesser, durchmesser);
}

Synthesizer

import processing.sound.*;
TriOsc oszillator; // Synthesizerobjekt
Env huellkurve; // Hüllkurvenobjekt
// Huüllkurve
float A = 0.001; // AttackTime
float D = 0.004; // DecayTime, SustainTime
float S = 0.3; // SustainLevel
float R = 0.2; // ReleaseTime
float lautstaerke = 0.8;
// Midi-Noten
int[] noten = { 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72};
int geschwindigkeit = 200; // Millisekunden
int metronom = millis(); // Taktgeber
int notenzaehler = 0; // Position in Notensequenz
void setup() {

size (400, 400);
background (255);
oszillator = new TriOsc(this);
huellkurve = new Env(this);
}

void draw() {
R = map( mouseX, 0 , width, 0, 0.2 ); // Skalierung
if ((millis() > metronom) && (notenzaehler < noten.length)){
oszillator.play( midiToFreq (noten[notenzaehler]), lautstaerke );
huellkurve.play( oszillator, A, D, S, R ); // Huüllkurve anwenden
metronom = millis() + geschwindigkeit; // Taktgeber
notenzaehler = notenzaehler + 1; // Nächste Note in Sequenz
if (notenzaehler == 12) {notenzaehler = 0;} // Notensequenzloop
}
}

// Midinote in Frequenzhöhe umrechnen
float midiToFreq( int note ){
return (pow(2, ((note-69)/12.0)))*440;
}

 zurück zur Übersicht 


Mindwave

Gehirnwellen

import processing.serial.*;
import pt.citar.diablu.processing.mindset.*;
MindSet gehirnwellen; // Mindwaveobjekt
int konzentration;
import processing.sound.*;
TriOsc oszillator; // Synthesizerobjekt
Env huellkurve; // Hüllkurvenobjekt
float lautstaerke = 0.8;
int frequenz = 0;

void setup() {
size (400, 400);
background (255);
fill (255);
noStroke ();
oszillator = new TriOsc(this);
huellkurve = new Env(this);
gehirnwellen = new MindSet (this, "/dev/tty.MindWave");
}

void draw() {
background (map(konzentration, 0, 100, 0, 255));
rect (width/2-5, height, 10, -konzentration*4);
lautstaerke = map(konzentration, 0, 100, 0.8, 0.1);
frequenz = int(map(konzentration, 0, 100, 0, 80));
oszillator.play (frequenz, lautstaerke);
huellkurve.play (oszillator, 0.001, 0.004, 0.3, 0.2);
println ("Konzentration " + konzentration);
}

void attentionEvent(int attentionLevel) {
konzentration = attentionLevel;
}

 

 zurück zur Übersicht 


LeapMotion

Virtuelle Leinwand

import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentHashMap;

import com.leapmotion.leap.Controller;
import com.leapmotion.leap.Finger;
import com.leapmotion.leap.Frame;
import com.leapmotion.leap.Vector;
import com.leapmotion.leap.processing.LeapMotion;

LeapMotion leinwand;
ConcurrentMap<Integer, Vector> fingerPositions;

void setup()
{
size(800, 800);
background(0);
stroke(0);
strokeWeight(2);
frameRate(60);

leinwand = new LeapMotion(this);
fingerPositions = new ConcurrentHashMap<Integer, Vector>();
}

void draw() {
for (Map.Entry entry : fingerPositions.entrySet()) {
Vector position = (Vector) entry.getValue();
float x = leinwand.leapToSketchX(position.getX());
float y = leinwand.leapToSketchY(position.getY());
stroke( map(x,0,800,0,255), map(y,0,800,0,255), 255 );
point (x, y);
}
}

void onFrame(final Controller controller) {
Frame frame = controller.frame();
fingerPositions.clear();
for (Finger finger : frame.fingers()) {
int fingerId = finger.id();
fingerPositions.put(fingerId, finger.tipPosition());
}
}

 

 zurück zur Übersicht 


controlP5

Digitale Fader

import controlP5.*;
ControlP5 cp5;
int hintergrundfarbe = 100;
int durchmesser = 100;

void setup() {
size(400,400);
noStroke();
cp5 = new ControlP5(this); // Faderobjekt
cp5.addSlider("hintergrundfarbe")
.setPosition(10, 10)
.setRange(0,255)
;
cp5.addSlider("durchmesser")
.setPosition(10, 30)
.setRange(0,350)
;
}

void draw() {
background(hintergrundfarbe);
ellipse(width/2, height/2, durchmesser, durchmesser);
}

 

 zurück zur Übersicht 


Kinect

Freisteller

import org.openkinect.freenect.*;
import org.openkinect.processing.*;
Kinect kamera; // Kameraobjekt definieren
int minTiefe = 0;
int maxTiefe = 800; // maximal 2048
float kamerawinkel = 30; // zwischen 0 und 30
int pixelabstand = 8;
float durchmesser;

void setup() {
size (620, 480);
noFill ();
stroke (255);
kamera = new Kinect(this); // Kameraobjekt erstellen
kamera.initDepth(); // Tiefeninformation des Bildes aktivieren
kamera.setTilt(kamerawinkel); // Kamerawinkel verändern
}

void draw() {
background(0);
int[] dataTiefe = kamera.getRawDepth(); // Tiefeninformation 0 bis 2048
for (int x = 0; x < kamera.width; x = x + pixelabstand) {
for (int y = 0; y < kamera.height; y = y + pixelabstand) {
if (dataTiefe[ y*kamera.width + x ] < maxTiefe) {
durchmesser = map (dataTiefe[ y*kamera.width + x ], 0, 2048, 0, 200);
ellipse (x, y, durchmesser, durchmesser);
}
}
}
}

Punktwolke

import org.openkinect.freenect.*;
import org.openkinect.processing.*;
Kinect kamera;
float[] tiefenmeter = new float[2048];
float drehung = 0;
void setup() {
size(800, 600, P3D);
kamera = new Kinect(this);
kamera.initDepth();
for (int n = 0; n < tiefenmeter.length; n++) {
tiefenmeter[n] = tiefe_in_meter (n);
}
}

void draw() {
background (0);
translate (width/2, height/2, -50);
rotateY (drehung);
int[] tiefe = kamera.getRawDepth();
int filter = 4;
float zoom = 800;
for (int x = 0; x < kamera.width; x += filter) {
for (int y = 0; y < kamera.height; y += filter) {
int xypos = y*kamera.width + x; // XY-Welt
int tiefenWert = tiefe[xypos]; // Tiefe
if (tiefenWert < 800) { // Freisteller
PVector v = tiefe_zu_welt (x, y, tiefenWert); // XYZ-Welt
stroke(255); // Zeichenelement
pushMatrix();
translate (v.x*zoom, v.y*zoom, zoom - v.z*zoom);
rect (0, 0, 1, 1);
popMatrix();
}
}
}
drehung += 0.015f;
}

float tiefe_in_meter (int tiefenWert) { // 0 bis 2048 in Metern
if (tiefenWert < 2047) {
return (float)(1.0 / ((double)(tiefenWert)
* -0.0030711016 + 3.3309495161));
}
return 0.0f;
}

PVector tiefe_zu_welt (int x, int y, int tiefenWert) {
final double fx_d = 1.0 / 5.9421434211923247e+02;
final double fy_d = 1.0 / 5.9104053696870778e+02;
final double cx_d = 3.3930780975300314e+02;
final double cy_d = 2.4273913761751615e+02;
PVector result = new PVector();
double tiefe = tiefenmeter[tiefenWert];
result.x = (float)((x - cx_d) * tiefe * fx_d);
result.y = (float)((y - cy_d) * tiefe * fy_d);
result.z = (float)(tiefe);
return result;
}

 zurück zur Übersicht 


Myo

Gestensteuerung

import de.voidplus.myo.*;
Myo myo;
float durchmesser = 10;

void setup() {
size (400, 400);
noStroke ();
rectMode (CENTER);
background (0);
fill (0);
myo = new Myo(this);
}

void draw() {
ellipse (width/2, height/2, durchmesser, durchmesser);
}

void myoOnPose (Myo myo, long timestamp, Pose pose) {
switch (pose.getType()) {
case FIST:
rect(width/2, height/2, durchmesser, durchmesser);
myo.vibrate();
break;
case FINGERS_SPREAD:
background (0);
fill (255);
break;
case DOUBLE_TAP:
background(255);
fill(0);
break;
case WAVE_IN:
durchmesser = durchmesser - 25;
break;
case WAVE_OUT:
durchmesser = durchmesser + 25;
break;
default:
break;
}
}

 

 zurück zur Übersicht