<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" media="screen" href="/~d/styles/rss1full.xsl"?><?xml-stylesheet type="text/css" media="screen" href="http://feeds.feedburner.com/~d/styles/itemcontent.css"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns="http://purl.org/rss/1.0/" xmlns:feedburner="http://rssnamespace.org/feedburner/ext/1.0"><channel rdf:about="http://www.creativecoding.org/examples"><title>Recent Examples</title><link>http://www.creativecoding.org/examples</link><description>The latest Examples from the Creative Coding collection.</description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Studio NAND</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><dc:date /><atom10:link xmlns:atom10="http://www.w3.org/2005/Atom" rel="self" type="application/rdf+xml" href="http://feeds.feedburner.com/cc-recentexamples" /><feedburner:info uri="cc-recentexamples" /><atom10:link xmlns:atom10="http://www.w3.org/2005/Atom" rel="hub" href="http://pubsubhubbub.appspot.com/" /><items><rdf:Seq><rdf:li rdf:resource="http://www.creativecoding.org/example/text:satzlaenge-abbilden" /><rdf:li rdf:resource="http://www.creativecoding.org/example/simulation:brownsche-irrfahrt" /><rdf:li rdf:resource="http://www.creativecoding.org/example/processing:sensitive-partikel" /><rdf:li rdf:resource="http://www.creativecoding.org/example/processing:mausverfolger" /><rdf:li rdf:resource="http://www.creativecoding.org/example/text:schriftzeichen-verbinden-2" /><rdf:li rdf:resource="http://www.creativecoding.org/example/text:schriftzeichen-verbinden-1" /><rdf:li rdf:resource="http://www.creativecoding.org/example/text:schriftzeichen-manuell-positionieren" /><rdf:li rdf:resource="http://www.creativecoding.org/example/text:maskierter-text" /><rdf:li rdf:resource="http://www.creativecoding.org/example/audio:frequenz-gruppen-ermitteln" /><rdf:li rdf:resource="http://www.creativecoding.org/example/audio:simples-spektrum-wellenform" /></rdf:Seq></items></channel><item rdf:about="http://www.creativecoding.org/example/text:satzlaenge-abbilden"><title>Satzlänge abbilden (text)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/DC1tUS54n8w/text:satzlaenge-abbilden</link><dc:date>2012-03-25T12:34:27+0000 (UTC)</dc:date><dc:description><![CDATA[Dies ist eine simple Textvisualisierung, welche die Länge der einzelnen Sätze durch entsprechend lange Rechtecke präsentiert. Zu Beginn teilen wir den gesamten Text <tt>txt</tt> mit <a href="/lesson/topics/text/arbeiten-mit-text-in-processing#text_modifizieren" class="intern lesson">split()</a> an jedem Punkt und speichern das Resultat im <a href="/lesson/basics/processing/arrays" class="intern lesson">Array</a> <tt>sentences</tt>. Diese Variable ist global definiert und kann deswegen überall im Programm benutzt werden. Im <a href="http://www.processing.org/reference/setup_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: setup()">setup()</a> Block durchlaufen wir ebenfalls alle Sätze mit einer <a href="/lesson/basics/processing/variablen-schleifen#for_schleife" class="intern lesson">for-Schleife</a>, um die Länge des Satzes mit den meisten Schriftzeichen in der Variable <tt>maxLength</tt> abzulegen. Wir benötigen diesen Wert für das spätere Einfärben der Balken.<br />
Im <a href="http://www.processing.org/reference/draw_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: draw()">draw()</a> Teil nutzen wir die gleiche <em>for</em>-Schleife und legen jeden Satz einzeln im <em>String</em> <tt>sentence</tt> ab. Um alle Leerzeichen am Anfang und Ende des Satzes zu entfernen, rufen wir die <span class="function-name">trim</span><span class="function-params">()</span> Funktion auf.
<pre class="brush: processing" dir="ltr">String sentence = trim (sentences[i]);</pre>
Nach dem simplen Abbilden des Satzes mit <span class="function-name">text</span><span class="function-params">()</span> ermitteln wir dessen länge. Ähnlich wie bei der Länge von <a href="/lesson/basics/processing/arrays" class="intern lesson">Arrays</a> greifen wir diese Eigenschaft mittels <em>length</em> ab; jedoch ist dies bei <em>String</em> eine Funktion und erfordert ein Klammerpaar: <tt>()</tt>.
<pre class="brush: processing" dir="ltr">int sentenceLength = sentence.length ();</pre>
Zum Abschluss nutzen wir den Wert von <tt>sentenceLength</tt> und interpolieren ihn mittels <a href="http://www.processing.org/reference/map_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: map()">map()</a> um die Füllfarbe des Rechtecks abhängig von der Satzlänge zu bestimmen.<h4>Example code</h4><pre class="brush: processing" dir="ltr">// Array zum Speichern der einzelnen S&auml;tze
String[] sentences;

// Variable zum Speichern der 
// maximalen Satzl&auml;nge
int maxLength = 0;

void setup () {
    size (550, 200);

    // Striche deaktivieren
    noStroke ();

    // Text zusammenf&uuml;gen; aus Platz-
    // gr&uuml;nden mit += Dies k&ouml;nnte auch
    // ein kompletter String sein.
    String txt = &quot;Sunny side up. Thats how fried eggs should be.&quot;;
    txt += &quot;Yes. And we love to have eggs in the afternoon as well.&quot;;

    // Text am .-Zeichen trennen und einzelne
    // Teile im array 'sentences' ablegen
    sentences = split (txt, &quot;.&quot;);
    
    // Laufe &uuml;ber alle S&auml;tze
    for (int i=0; i &lt; sentences.length; i++) {
        
        // Wenn Satz mind. 1 Zeichen hat
        if (sentences[i].length () &gt; 0) {
            // F&uuml;ge den . wieder an
            sentences[i] += &quot;.&quot;;
            // Wenn Satz l&auml;nger als 'maxLength'
            if (sentences[i].length () &gt; maxLength) {
                // Setze 'maxLength' auf aktuelle Satzl&auml;nge
                maxLength = sentences[i].length ();
            }
        }
    }
}

void draw () {    
    // Hintergrund mit Grau f&uuml;llen
    background (76);

    // F&uuml;r jeden Satz im Text...
    for (int i=0; i &lt; sentences.length; i++) {

        // Leerzeichen am Beginn und Ende 
        // des Satzes entfernen
        String sentence = trim (sentences[i]);

        // Wenn der Satz mind. 1 Zeichen besitzt
        if (sentence.length () &gt; 0) {
            
            // Setze Textf&uuml;llfarbe
            fill (239);

            // Text darstellen
            text (sentence, 20, 30 + i * 18);

            // Satzl&auml;nge in der Variable 'sentenceLength' speichern
            int sentenceLength = sentence.length ();

            // Die Maus-x-Position auf einen Wert 
            // zwischen 1 und 3 interpolieren
            float mouse = map (mouseX, 0, width, 1, 3);
            
            // F&uuml;llfarbe anhand der Satzl&auml;nge definieren
            color c = color (map (sentenceLength, 1, maxLength, 0, 255), 170, 178);
            
            // Rechteck F&uuml;llfarbe anwenden
            fill (c);

            // Rechtecke (entsprechend der Satzl&auml;nge) zeichnen
            rect (20, 110 + i * 15, sentenceLength * mouse, 10);
        }
    }
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/DC1tUS54n8w" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/text:satzlaenge-abbilden</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/simulation:brownsche-irrfahrt"><title>Brownsche Irrfahrt (simulation)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/vx0WNgPdCbM/simulation:brownsche-irrfahrt</link><dc:date>2012-03-23T18:45:14+0000 (UTC)</dc:date><dc:description><![CDATA[In der Stochastik ist die <a href="http://de.wikipedia.org/wiki/Zufallsbewegung" class="extern http" target="_blank">Irrfahrt</a> (engl. Random Walk) ein Prozess der zufällige Richtungsänderung. Die Schrittweite ist immer gleich (in diesem Beispiel beträgt sie 1 Pixel). Um das Ergebnis visuell spannender zu gestalten, finden <span class="constant-name">30</span> Random Walks zeitgleich im Sketchfenster statt. Die Variable <span class="constant-name">NUM</span> gibt diese Zahl vor und bestimmt wie viele Felder die <a href="/lesson/basics/processing/arrays" class="intern lesson">Arrays</a> <tt>pos</tt> und <tt>col</tt> besitzen. In <tt>pos</tt> repräsentiert jedes Feld einen <em>PVector</em> – der Ort wo die Position im <span class="constant-name">2D</span> Raum mittels <tt>x</tt> und <tt>y</tt> abgelegt wird. Hingegen speichern wir in <tt>col</tt> pro Feld einen <span class="constant-name">RGB</span>-Farbwert für das spätere Zeichnen. Alle Eigenschaften, Position und Farbe, werden zu Beginn im <a href="http://www.processing.org/reference/setup_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: setup()">setup()</a> Block definiert.
<pre class="brush: processing" dir="ltr">for (int i=0; i &lt; NUM; i++) {
    pos[i] = new PVector (random (width), random (height));
    col[i] = color (random (90, 250), 170, 178);
}</pre>
Innerhalb der <a href="/lesson/basics/processing/variablen-schleifen#for_schleife" class="intern lesson">for-Schleife</a> wird jedes Feld der beiden Arrays befüllt, wobei dem Index <tt>i</tt> jeweils eine Position und Farbe zugesprochen wird. Die selbe Schleifen-Struktur verwenden wir anschließend im <a href="http://www.processing.org/reference/draw_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: draw()">draw()</a>, um die Positionen zufällig zu bewegen und letztendlich abzubilden. Die Bewegung geht mit dem <a href="/lesson/basics/processing/zufall-events" class="intern lesson">random()</a> Aufruf für <tt>x</tt> und <tt>y</tt> vonstatten; wir fügen der aktuellen Position auf beiden Achsen einen Zufallswert im Bereich von -1 bis 1 hinzu.
<pre class="brush: processing" dir="ltr">pos[i].x += random (-1, 1);
pos[i].y += random (-1, 1);</pre>
Diese Zeilen beschreiben die Bewegung. Damit der Punkt die Zeichenfläche nicht verlässt, überprüfen wir die Grenzen (0 &rarr; Breite/Höhe) durch vier <a href="http://www.processing.org/reference/if.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: if">if</a> Abfragen und Zeichnen den Punkt mittels <a href="http://www.processing.org/reference/point_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: point()">point()</a>.<h4>Example code</h4><pre class="brush: processing" dir="ltr">// Anzahl der Punkte
int NUM = 30;
// Array zum speichern der Positionen
PVector[] pos = new PVector[NUM];
// Array zum speichern der Farben
color[] col = new color[NUM];

void setup () {
    // Gr&ouml;&szlig;e und Hintergrundfarbe 
    // des Sketches definieren
    size(550, 200);
    background (79);
    
    // F&uuml;r jeden Punkt...
    for (int i=0; i &lt; NUM; i++) {
        // Lege Zufallsposition fest
        pos[i] = new PVector (random (width), random (height));
        // Lege Zufallsfarbe fest
        col[i] = color (random (90, 250), 170, 178);
    }
}

void draw () {
    
    // F&uuml;r jeden Punkt im array 'pos'
    for (int i=0; i &lt; NUM; i++) {
        
        // die Position zuf&auml;llig modifiziere
        pos[i].x += random (-1, 1);
        pos[i].y += random (-1, 1);
        
        // &Uuml;berpr&uuml;fe an allen Seiten des Sketchfensters
        // ob der Punkt dieses gerade verl&auml;sst, verhindern!
        
        // Links
        if (pos[i].x &lt; 0)
            pos[i].x = 0;
        // Rechts
        if (pos[i].x &gt; width)
            pos[i].x = width;
        // Oben
        if (pos[i].y &lt; 0)
            pos[i].y = 0;
        // Unten
        if (pos[i].y &gt; height)
            pos[i].y = height;
        
        // Setze die Strich-(Punkt)-Farbe
        // f&uuml;r den entsprechenden Punkt im Array
        stroke (col[i]);
        
        // betreffendes Pixel in der Zeichfl&auml;che
        // mit der Strichfarbe f&uuml;llen
        point (int (pos[i].x), int (pos[i].y));
    }
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/vx0WNgPdCbM" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/simulation:brownsche-irrfahrt</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/processing:sensitive-partikel"><title>Sensitive Partikel (processing)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/jp4-epil0hY/processing:sensitive-partikel</link><dc:date>2012-03-23T16:03:15+0000 (UTC)</dc:date><dc:description><![CDATA[Dieser interaktive Sketch zeigt, auf welche Art und Weise man visuellen Elementen simple Verhaltensweisen mit auf den Weg geben kann. Grundsätzlich bedienen wir uns dabei dem Ansatz der <a href="/lesson/basics/processing/objekte" class="intern lesson">objekt orientierte Programmierung</a>.<br />

Untergliedert in zwei Teile besteht das Programm aus einem üblichen Processing-Sketch mit <a href="http://www.processing.org/reference/setup_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: setup()">setup()</a> / <a href="http://www.processing.org/reference/draw_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: draw()">draw()</a> Block, in welchem der Sketch initialisiert und gesteuert wird. Der zweite Teil beschreibt unser Model <em>Circle</em> (bzw. die <a href="/lesson/basics/processing/objekte#klasse" class="intern lesson">Klasse</a> <em>Circle</em>); die Beschaffenheit und Funktionalität die jeder Kreis im Sketchfenster mitbringt. Wir nehmen zuerst diesen – spannenderen Teil – genauer unter die Lupe.<br />
<br />
Im dafür angelegten Tab <em>Circle</em> leiten wir die Klasse mit dem Ausdruck <tt>class</tt> ein und legen vorab zwischen den Geschweiften Klammern <tt>{ … }</tt> die Eigenschaften des Kreises fest.
<pre class="brush: processing" dir="ltr">class Circle {
    boolean iq;
    float x, y;
    float xTarget, yTarget;
    float radius = 5;
    //...
}</pre>
Neben den üblichen Eigenschaften wie Position und Radius besitzt jeder Kreis unteranderem Information über seine Cleverness <tt>iq</tt> (schlau oder dumm) und seine Zielposition <tt>xTarget, yTarget</tt> (alle hier definierte Variablen werden im Programm für jeden einzelnen Kreis vorhanden sein).<br />
Der weitere Code innerhalb des <em>Circle</em> Tabs beinhaltet den <a href="/lesson/basics/processing/objekte#konstruktor" class="intern lesson">Konstruktor</a> zur Initialisierung und einige <a href="/lesson/basics/processing/objekte#methode" class="intern lesson">Methoden</a> (spezifische Fähigkeiten des Kreises). Die wichtigste von diesen ist mit dem Namen <span class="function-name">move</span><span class="function-params">()</span> betitelt und ist für die Bewegung des Kreises verantwortlich. Die Logik hierbei ist eine Simple Frage: Wie nah ist die Maus, bzw. bewegt sich der Kreis zu ihr hin oder von ihr weg? Um ein Antwort zu erhalten, ermitteln wir zu Beginn die Distanz zwischen Maus und Kreis:
<pre class="brush: processing" dir="ltr">if (dist (x, y, mouseX, mouseY) &lt;= RANGE) {
    &hellip;</pre>
Ist diese Aussage wahr, befindet sich die Maus nah am Kreis und veranlasst diesen sich zu bewegen. Abhängig von seiner Cleverness (die Variable <tt>iq</tt>) wird das neue Ziel des Kreises entweder dichter zur Mausposition (dumm) oder weiter <span class="function-name">entfernt</span><span class="function-params">(schlau)</span> definiert; und der Bewegungszustand <tt>slideStat</tt> auf wahr gesetzt. Mit diesem Schritt hat der Kreis ein Ziel und die Information sich zu bewegen.<br />
Im letzten Abschnitt der <span class="function-name">move</span><span class="function-params">()</span> Methode wird der <tt>slideStat</tt> des Kreises erfragt und wenn <tt>true</tt> weiter zu seinem Ziel verschoben:
<pre class="brush: processing" dir="ltr">x -= (x - xTarget) / slideSpeed;
y -= (y - yTarget) / slideSpeed;</pre>
Die Methode <tt>bounceCircle()</tt> ist ein weiterer wichtiger Bestandteil der Kreis-Animation und stellt das Nichtverlassen des Sketchfensters sicher.<br />
<br />
Im Sketch-Tab <em>Circles-example-01</em> werden im <a href="http://www.processing.org/reference/setup_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: setup()">setup()</a> Block mit der Funktion <span class="function-name">createCircles</span><span class="function-params">()</span> <span class="constant-name">40</span> Kreise erzeugt:
<pre class="brush: processing" dir="ltr">for (int i=0; i &lt; circles.length; i++) {
    float x = random (width);
    float y = random (height);
    circles[i] = new Circle (x, y);
}</pre>
Initialisiert und versehen mit einer zufälligen Position "existieren" diese Kreise nun in unserem Sketchfenster und müssen in jedem Frame aufgefordert werden auf die Maus zu reagieren. Dies passiert innerhalb des <a href="http://www.processing.org/reference/draw_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: draw()">draw()</a> Blocks. Wir laufen mit einer for-Schleife durch das <tt>circles</tt> <a href="/lesson/basics/processing/arrays" class="intern lesson">Array</a> und rufen die <span class="function-name">move</span><span class="function-params">()</span> Methode auf, bevor wir letztendlich den Kreis an seiner jeweiligen Position mit dem <a href="/lesson/basics/processing/einstieg-in-processing#ellipse" class="intern lesson">ellipse()</a> Befehl darstellen.<br />
<br />
Um die Funktionsweise abzubilden sind folgende Tastenbelegungen im Programm implementiert:
<ul class="text-list"><li class="text-list-element"><strong>n</strong> Sketch mit erneut mit <span class="constant-name">40</span> Kreisen befühlen
</li><li class="text-list-element"><strong>t</strong> Kreis-Ziele anzeigen/ausblenden
</li><li class="text-list-element"><strong>r</strong> Sensitiven Bereich anzeigen/ausblenden</ul></li><h4>Example code</h4><div id="exampleTabs0" class="tabs"><ul><li><a href="#exampleTabs0-1">Circles-example-01</a></li><li><a href="#exampleTabs0-2">Circle</a></li></ul><div id="exampleTabs0-1"><pre class="brush: processing">// Display setting: zeichne sensitiven Bereich
boolean dRange = true;
// Display setting: zeichne Ziel
boolean dTarget = true;
// Display setting: zeichne Schweif
boolean dTail = true;

// Array zum Ablegen aller circles
Circle circles[] = new Circle[40];

void setup() {
    // Sketch-Einstellungen
    size (550, 220);
    smooth ();
    // Erstelle circles an zuf&auml;lligen Positionen
    createCircles ();
}

void draw() {
    background (79);

    // F&uuml;r jeden einzelnen circle im 
    // array 'circles'...
    for (int i=0; i &lt; circles.length; i++) {

        // Bewege circle 'i'
        circles[i].move ();

        // Zeige debug-Informationen an,
        // wenn diese aktiviert sind
        if (dRange) displayRange(i);
        if (dTarget) displayTarget(i);
        if (dTail) displayTail(i);

        // Lege die F&uuml;llfarbe f&uuml;r den 'circle' fest
        // entsprechend seiner 'Fluchteigentschaft'
        if (circles[i].iq) {
            fill (229, 90, 38);
        }
        else {
            fill (138, 170, 178);
        }

        // Setze Strichfarbe auf wei&szlig;
        stroke (239);

        // Zeichne den circle 'i' an seiner Position
        ellipse (circles[i].x, circles[i].y, circles[i].radius*2, circles[i].radius*2);
    }
}

// Methode zum Erstellen und Bef&uuml;llen des 'circles' 
// Arrays. Alle circles werden zuf&auml;llig positioniert.
void createCircles () {
    // F&uuml;r jedes Feld im 'circles' array...
    for (int i=0; i &lt; circles.length; i++) {
        // Ermittle Zufallsposition
        float x = random (width);
        float y = random (height);
        // Erstelle neuen circle
        circles[i] = new Circle (x, y);
    }
}

// Methode zum Darstellen des sensitiven Bereichs
// um einen circle herum.
void displayRange (int id) {
    // Wenn der circle 'id' sichtbar ist...
    if (circles[id].radius &gt; 0) {
        // Aktiver 'range' Durchmesser
        float diam = circles[id].RANGE * 2;
        // Deaktiviere F&uuml;llfarbe
        noFill ();
        // Setze Linienfarbe
        stroke (150);
        // Zeichne Range-Bereich
        ellipse (circles[id].x, circles[id].y, diam, diam);
    }
}

// Methode zum Darstellen des Bewegungs-Ziels.
void displayTarget (int id) {
    // Wenn circle 'id' sichtbar ist...
    if (circles[id].radius &gt; 0) {
        // Setze Strichfarbe
        stroke (239);
        // Zeichne Linie zwischen aktueller circle-Position
        // und dem circle-Ziel
        line (circles[id].x, circles[id].y, circles[id].xTarget, circles[id].yTarget);
    }
}

// Methode zum Darstellen des circle-Schweifs.
void displayTail (int id) {
    // Wenn circle 'id' sichtbar ist...
    if (circles[id].radius &gt; 0) {
        // Deaktiviere F&uuml;llfarbe
        noFill ();
        // F&uuml;r alle Schweifpositionen
        for (int i=circles[id].tailArr.length-1; i &gt; 0; i--) {
            // Passe Strichfarbe an
            stroke (170, 170, 170, i*20);
            // Passe Kreisradius an
            float rad  = circles[id].radius*8/i;
            // Zeichne Schweifelement
            ellipse (circles[id].tailArr[i][0], circles[id].tailArr[i][1], rad, rad);
        }
    }
}

// Tastatur-Event zum Einstellen der display settin
void keyPressed () {
    if (key == 'b' || key == 'B') dTail = !dTail;
    if (key == 'n' || key == 'N') createCircles();
    if (key == 'r' || key == 'R') dRange = !dRange;
    if (key == 't' || key == 'T') dTarget = !dTarget;
}</pre></div><div id="exampleTabs0-2"><pre class="brush: processing">class Circle {
    
    // Gr&ouml;&szlig;e des sensitiven Circle-Bereichs
    float RANGE = 30;
    
    // Bewegungszustand (ja/nein)
    boolean slideStat = false;
    // Cleverness (schlau=true,dumm=false)
    boolean iq;
    
    // Aktuelle Circle-Position
    float x, y;
    // Circle-Zielposition
    float xTarget, yTarget;
    // Circle Radius
    float radius = 5;
    
    // Fliehdistanz
    float slideRange = 6;
    float slideSpeed = 12;
    
    // Maximale Anzahl an Schweifelementen
    int maxTailNum = 21;
    // Aktuelles Schweifelement
    int tailCount;
    
    // Schweif-array mit x/y Positionen
    // f&uuml;r 'maxTeilNum' Schweifelemente
    float[][] tailArr = new float[maxTailNum][2];
    
    
    // Konstrutor Funktion zum Initialisieren
    // eines neuen Circles.
    Circle (float xPos, float yPos) {
        
        // &Uuml;bernimm Startposition
        x  = xPos;
        y  = yPos;
        // Definieren zuf&auml;lliges Start-Ziel
        xTarget = random (x-2, x+2);
        yTarget = random (y-2, y+2);
        // Setze 'schlau/dumm' Status
        // basierent auf 50/50 chance
        iq = (random (1) &lt; 0.5f);
        
        tailCount = 0;
        
        // Erstelle leeres Schweif-array und
        // setze alle Positionen auf die aktuelle
        for (int i=0; i &lt; this.tailArr.length; i++) {
            tailArr[i][0] = x;
            tailArr[i][1] = y;
        }
    }
    
    // Funktion zum Bewegen des Circles. Je nach 'cleverness'
    // bewegt sich dieser zur Maus hin bzw. weg.
    public void move () {
        
        // Wenn die Distanz zwischen Circle und Maus-Position
        // kleiner/gleich der sensitiven RANGE ist...
        if (dist (x, y, mouseX, mouseY) &lt;= RANGE) {
            // Wenn Circle schlau ist...
            if (iq) {
                // Verschiebe Circle weg von der Maus
                xTarget = x - (mouseX - x) * slideRange;
                yTarget = y - (mouseY - y) * slideRange;
            }else{
                // Verschiebe Circle hin zur Maus
                xTarget = mouseX + radius * 2;
                yTarget = mouseY + radius * 2;
            }
            // Setze den Bewegungsstatus auf true
            slideStat = true;
        }
        
        // Wenn Circle dumm ist...
        if (!iq) {
            // Wenn die Maus den Circle ber&uuml;hrt...
            if (dist (x, y, mouseX, mouseY) &lt;= radius + 1) {
                // Wenn Circle-radius gr&ouml;&szlig;er als 0 ist...
                if (radius &gt; 0) {
                    // Reduziere Radius um 0.2
                    radius -= 0.2;
                }else{
                    // Anderenfalls setze Radius auf 0
                    radius = 0;
                }
            }
        }
        
        // Wenn Bewegungsstatus 'true' ist...
        if (slideStat) {
            // &Uuml;berpr&uuml;fe ob Distanz zwischen Circle-Position
            // und Circle-Ziel kleiner/gleich 1 ist...
            if (dist (x, y, xTarget, yTarget) &lt;= 1) {
                // Wenn ja, setze Bewegungsstatus auf 'false'
                slideStat = false;
            }
            
            // Teste ob sich der Circle aus dem 
            // Sketchfenster bewegt
            bounceCircle ();
            
            // Bewege den Circle einen 'slideSpeed'
            // Schritt zu seinem Ziel
            x -= (x - xTarget) / slideSpeed;
            y -= (y - yTarget) / slideSpeed;
            
            // F&uuml;ge die Aktuelle Position zum Schweif hinzu
            createTail ();
        }else{
            // Anderenfalls, bearbeite Schweif
            removeTail ();
        }
    }
    
    
    // Funktion zum Abprallen des Circles an den
    // R&auml;ndern des Sketchfensters.
    private void bounceCircle () {
        // Linke Seite des Sketchfensters
        if (x &lt;= radius * 2) {
            xTarget = x + (x - xTarget);
            yTarget = y - (y - yTarget);
        }
        // Obere Seite des Sketchfensters
        if (y &lt;= radius * 2) {
            xTarget = x - (x - xTarget);
            yTarget = y + (y - yTarget);
        }
        // Rechte Seite des Sketchfensters
        if (x &gt;= width - radius * 2) {
            xTarget = x - (xTarget - x);
            yTarget = y - (y - yTarget);
        }
        // Untere Seite des Sketchfensters
        if (y &gt;= height - radius * 2) {
            xTarget = x - (x - xTarget);
            yTarget = y - (yTarget - y);
        }
    }
    
    private void createTail () {
        if (slideStat == true) {
            if (tailCount &gt; maxTailNum-1) {
                tailCount = 0;
            }
            tailArr[tailCount][0] = x;
            tailArr[tailCount][1] = y;
        }
        tailCount++;
    }
    
    private void removeTail () {
        if (slideStat == false) {
            for (int i=0; i &lt; tailArr.length; i++) {
                tailArr[i][0] = -radius * 1.2;
                tailArr[i][1] = -radius * 1.2;
            }
        }
    }
}</pre></div></div>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/jp4-epil0hY" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/processing:sensitive-partikel</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/processing:mausverfolger"><title>Mausverfolger (processing)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/mcCJ3siI_Xs/processing:mausverfolger</link><dc:date>2012-03-21T19:56:43+0000 (UTC)</dc:date><dc:description><![CDATA[Bei anderen Mausverfolger-Beispielen setzt man üblicherweise die Position eines visullen Objekts gleich der aktuellen Mausposition, bzw. nähert diese an. Als zweiten Schritt bewegen wir in dieser Version das visuelle Objekt nicht nur zur Maus, sondern rotieren es auch noch in deren Richtung.<br />
<br />
Der erste Teil – die Bewegung – basiert auf dem Ansatz der <a href="/lesson/basics/processing/animation#non_lineare_animation" class="intern lesson">non-linearen Animation</a>. Wir berechnen die aktuelle Distanz zwischen Maus und Dreieck und verschieben das Dreieck um 1/10tel der verbleibenden Strecke:
<pre class="brush: processing" dir="ltr">xpos = xpos + (mouseX - xpos) / 10.0;
ypos = ypos + (mouseY - ypos) / 10.0;</pre>
Um das Dreieck um sein Zentrum zu rotieren, bedienen wir uns dem <a href="http://www.processing.org/reference/translate_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: translate()">translate()</a> Befehl und <a href="/lesson/basics/processing/transformationen" class="intern lesson">verschieben den Koordinatenursprung</a> um die Position.
<pre class="brush: processing" dir="ltr">translate (xpos, ypos);</pre>
Im Anschluss berechnen wir den Anstieg (<tt>angle</tt>) zwischen Dreiecksposition - Maus, und rotieren die Zeichenfläche um den entsprechenden Winkel.
<pre class="brush: processing" dir="ltr">float angle = atan2 (mouseY - ypos, mouseX - xpos) + PI/2;
rotate (angle);</pre>
Da nun das gesamte Koordinatensystem verschoben und rotiert ist, kann das Dreieck an einer festen Position gezeichnet werden.<h4>Example code</h4><pre class="brush: processing" dir="ltr">// globale Variablen zum Ablegen 
// der aktuellen Dreiecks-Position
float xpos = 0;
float ypos = 0;

void setup () {
    size (550, 220);
    smooth ();
}

void draw () {
    // Hintergrund einf&auml;rben
    fill (76, 10);
    noStroke ();
    rect (0, 0, width, height);
    
    // nonlineare Bewegung des Bildes zur Maus
    xpos = xpos + (mouseX - xpos) / 10.0;
    ypos = ypos + (mouseY - ypos) / 10.0;

    // Koordinatensystem in Richtung
    // der Maus verschieben
    translate (xpos, ypos);
    
    // Winkel zwischen Dreick und Maus berechnen
    float angle = atan2 (mouseY - ypos, mouseX - xpos) + PI/2;
    
    // Koordinatensystem rotieren
    rotate (angle);
    
    // Dreieck darstellen
    fill (236);
    triangle (0, -10, 10, 10, -10, 10);
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/mcCJ3siI_Xs" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/processing:mausverfolger</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/text:schriftzeichen-verbinden-2"><title>Schriftzeichen verbinden #2 (text)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/bw90YYXrGrg/text:schriftzeichen-verbinden-2</link><dc:date>2012-03-20T23:26:31+0000 (UTC)</dc:date><dc:description><![CDATA[Dieses Beispiel ist eine simple Textvisualisierung, basierend auf der vorherigen Version: <a href="/example/text:schriftzeichen-verbinden-1" class="intern snippet">Schriftzeichen verbinden #1</a>. Auch hier werden alle Schriftzeichen eines bestimmten Typs miteinander verbunden, jedoch der eigentlich Text nicht dargestellt; wird sehen nur die resultierenden Kurven.
<div class="image"><img src="http://www.creativecoding.org//files/documents/txt-connect-char2-xl.png" alt="" style="display:block;margin-left:auto;margin-right:auto;" /></div><br />

Um diese Funktionalität nicht nur auf eine Zeile anzuwenden, müssen wir uns nicht nur die aktuelle <tt>x</tt>, sondern ebenfalls die <tt>y</tt>-Position merken. Innerhalb jedes <a href="http://www.processing.org/reference/draw_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: draw()">draw()</a>-Blocks legen wir dafür zwei Variablen an:
<pre class="brush: processing" dir="ltr">float x = 10;
float y = 10;</pre>
Die Werte <span class="constant-name">10</span> stehen dabei für die Startposition des imaginären Textes. Mittels einer <a href="http://www.processing.org/reference/for.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: for">for</a>-Schleife laufen wir durch den gesamten Text und halten nach dem gewünschten Zeichen <tt>token</tt> Ausschau. Wir verändern Zeichen für Zeichen den Wert von <tt>x</tt>, indem wir die Breite des aktuellen Zeichens auf <tt>x</tt> addieren:
<pre class="brush: processing" dir="ltr">x = x + charWidth;</pre>
Wird der Wert von <tt>x</tt> zu groß, setzen wir dies auf die Startposition zurück und verschieben die aktuelle Zeile um <span class="constant-name">20</span> Pixel nach unten:
<pre class="brush: processing" dir="ltr">if (x + charWidth &gt; width - margin) {
    x = margin;
    y = y + 20;
}</pre><h4>Example code</h4><pre class="brush: processing" dir="ltr">String txt;
PFont font;
float margin = 10;

// Gesuchtes Zeichen
char token = 'a';

void setup () {
    size (590, 250);
    smooth ();
    
    // Laden des Textes aus einem Textdokument
    String[] fileContent = loadStrings (&quot;my text file.txt&quot;);
    // Zusammenf&uuml;gen der Zeilen (mit Umbruch)
    txt = join (fileContent, &quot;\n&quot;);
    // Festlegen der Schrifteinstellungen
    font = createFont (&quot;Arial&quot;, 10);
    textFont (font);
}


void draw () {
    background (76);
    
    // Variablen zum Ablegen des letzten
    // Vorkommens vom gesuchten Buchstaben
    float xPrevious = 0;
    float yPrevious = 0;
        
    // Variablen zum Ablegen der Position
    // vom aktuellen Buchstaben
    float x = 10;
    float y = 10;
    
    // F&uuml;r jeden Buchstaben im Text...
    for (int i=0; i &lt; txt.length (); i++) {
        
        // Buchstaben an Position 'i' im
        // Text ausw&auml;hlen
        char c = txt.charAt (i);
        
        // Ermittlung der Buchstabenbreite
        float charWidth = textWidth (c);
        
        // Sicherstellung das die Position 
        // des aktuellen Buchstabens nicht das
        // Sketchfenster verlassen w&uuml;rde
        if (x + charWidth &gt; width - margin) {
            x = margin;
            y = y + 20;
        }
        
        // Wenn Buchstabe der Gesuchte ist...
        if (c == token) {
            // Zeichne einen Kreis an dessen Position
            fill (138, 170, 178);
            noStroke ();
            ellipse (x, y, 6, 6);
                   
            noFill ();
            stroke (239);
            // Verbinde aktuelles mit vorherigem
            // Vorkommen des gesuchten Buchstabens 
            curve (xPrevious, yPrevious - 40, xPrevious, yPrevious, x, y, x, y - 40);
            // Merke die aktuelle als vorherige Position
            // f&uuml;r n&auml;chstes Vorkommen
            xPrevious = x;
            yPrevious = y;
        }
        
        x = x + charWidth;
    }
}

void keyPressed () {
    // Wenn Taste gedr&uuml;ckt, &auml;ndere
    // den Wert des gesuchten Buchstabens
    token = key;
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/bw90YYXrGrg" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/text:schriftzeichen-verbinden-2</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/text:schriftzeichen-verbinden-1"><title>Schriftzeichen verbinden #1 (text)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/UWdqU2OOU5s/text:schriftzeichen-verbinden-1</link><dc:date>2012-03-15T19:47:39+0000 (UTC)</dc:date><dc:description><![CDATA[Dieses Beispiel läuft Zeichen für Zeichen durch einen gegebenen Text und verbindet alle Buchstaben eines bestimmten Typs.
<div class="image"><img src="http://www.creativecoding.org//files/documents/txt-connect-char1.png" alt="" style="display:block;margin-left:auto;margin-right:auto;" /></div><br />
Zu Beginn des draws werden zwei <a href="http://www.processing.org/reference/float.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: float">float</a> Variablen <tt>x</tt> und <tt>lastEx</tt> festgelegt. <tt>x</tt> steht für die aktuelle Zeichenposition an welcher nacheinander die einzelnen Buchstaben positioniert werden. <tt>lastEx</tt> steht für die Position des letzten e's – welche wir mit einer Bezierkurve verbinden.
<pre class="brush: processing" dir="ltr">float x = 0;
float lastEx = -1;</pre>
Im nächsten Schritt gehen wir mit einer <em>for</em>-Schleife durch alle Zeichen im Text und überprüfen, ob das aktuelle ein gesuchtes 'e' ist oder nicht.
<pre class="brush: processing" dir="ltr">for (int i=0; i &lt; myText.length (); i++) {
    if (c == searchChar) {</pre>
Ist dies der Fall, Zeichnen wir eine Bezierkurve zur letzten <tt>lastEx</tt>-Position (bzw. wenn nicht, merken wir uns die aktuelle als Start). Anderenfalls wird der Buchstabe im letzten Schritt einfach dargestellt und der Wert von <tt>x</tt> für die Position den nächsten Buchstabens um die Breite des Aktuellen erhöht.<h4>Example code</h4><pre class="brush: processing" dir="ltr">// String f&uuml;r den Text
String myText;
// PFont f&uuml;r die Schriftart
PFont font;
// Schriftgr&ouml;&szlig;e als Integer
int fontSize = 16;
// Breite des Randes
float margin = 14;
// Gesuchter Buchstabe
char searchChar = 'e';

void setup () {
    // Grundlegende Sketch-Einstellungen
    size (550, 200);
    smooth ();
    
    // Generiere die Schrift 'Arial';
    // muss daf&uuml;r im System aktiv sein
    font = createFont (&quot;Arial&quot;, fontSize);
    
    // Setze 'font' als Standardschrift
    // f&uuml;r alle Aufrufe von 'text()'
    textFont (font);
    
    // Bef&uuml;lle die Variable 'myText' mit Inhalt
    myText = &quot;So perhaps a \&quot;luck\&quot; gene that somehow confers a quantum mechanical&quot;;
}

void draw () {
    // Hintergrund mit grau f&uuml;llen
    background (76);
    
    // Positionierungsvariablen
    // initialisieren...
    float x = 0;
    float lastEx = -1;
    
    // Variable 'base' zur y-Positionierung
    float base = height / 2 - fontSize;
    
    // F&uuml;r jeden einzelnen Buchstaben im Text...
    for (int i=0; i &lt; myText.length (); i++) {
        
        // W&auml;hle Zeichen an Position 'i' aus
        char c = myText.charAt (i);

        // Wenn Zeichen ein 'e' ist...
        if (c == searchChar) {
            
            // Wenn dies nicht das erste 'e' ist...
            if (lastEx &gt; -1) {
                
                // Berechne die Entfernung zwischen
                // diesem und dem vorigen 'e'
                float space = x + margin - lastEx;
                space = space / 2;
                
                // Zeichne Kurve zwischen beiden 'e's
                stroke (138, 170, 178);
                strokeWeight (2);
                noFill ();
                bezier (
                    lastEx, 
                    base + 3, 
                    lastEx, 
                    base + 3 + space, 
                    x + margin, 
                    base + 3 + space, 
                    x + margin, 
                    base + 3
                );
            }
            // Merke die Position des akuellen
            // 'e's als 'lastEx'
            lastEx = margin + x;
        }
        
        // F&uuml;llfarbe abh&auml;ngig vom Buchstaben
        if (c == searchChar) {
            fill (229, 90, 38);
        }else{
            fill (239);
        }
        noStroke ();
        // Buchstaben darstellen
        text (c, margin + x, base);
        
        // Den Zeichen-'cursor' nach 
        // rechts verschieben...
        x = x + textWidth (c);
    }
}

void keyReleased () {
    searchChar = key;
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/UWdqU2OOU5s" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/text:schriftzeichen-verbinden-1</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/text:schriftzeichen-manuell-positionieren"><title>Schriftzeichen manuell positionieren (text)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/VW96e6cKdL8/text:schriftzeichen-manuell-positionieren</link><dc:date>2012-02-28T15:09:20+0000 (UTC)</dc:date><dc:description><![CDATA[Mit diesem Beispiel simulieren wir die Vorgehensweise einer Schreibmaschine. Wir gehen von einem Text (<a href="http://www.processing.org/reference/String.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: String">String</a>) namens <tt>txt</tt> aus und betrachten jeden einzelnen Buchstaben: positionieren diesen in der Zeichenfläche und geben ihm anhand dessen eine Füllfarbe. Als Grundlage dient und dafür folgende <span class="function-name">for</span><span class="function-params">()</span> Schleife:
<pre class="brush: processing" dir="ltr">for (int i=0; i &lt; txt.length (); i++) {
   ...
}</pre>
Da <tt>i</tt> zu Beginn den Wert 0 besitzt, fängt unser Programm mit dem ersten Buchstaben im Text an. Im Gegensatz stellt <tt>txt.length()</tt> das Limit der Schleife dar; das letzte Zeichen. Innerhalb der Schleife lesen wir jedes Schriftzeichen mit der Funktion <tt>txt.charAt(i)</tt> aus und legen es in der Variable <tt>c</tt> vom Typ <a href="http://www.processing.org/reference/char.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: char">char</a> ab.

<pre class="brush: processing" dir="ltr">char c = txt.charAt (i);</pre>

So weit, so gut. Der interessante Teil ist die Positionierung der Zeichen im Sketchfenster. Die beiden globalen Variablen <tt>x</tt> und <tt>y</tt> enthalten die aktuelle Position des Schreib-cursors; ein virtueller Anschlag der sich von der linken-oberen in die rechte-untere Ecke bewegt. Diese Bewegung (das Verschieben des cursors) geschiet durch die Einbeziehung der Zeichenbreite. Mittels <span class="function-name">textWidth</span><span class="function-params">()</span> erhalten wir die Breite in Pixel, welches das Zeichen <tt>c</tt> im Sketchfenster hat.

<pre class="brush: processing" dir="ltr">float charWidth = textWidth (c);</pre>

Diesen Wert von <tt>charWidth</tt> involvieren wir in einer <span class="function-name">if</span><span class="function-params">()</span> Bedingung mit der Frage: Ist die Position des aktuellen Zeichens mit der Breite <tt>charWidth</tt> an der Position <tt>x</tt> noch im Sketchfenster; oder nicht? Ist dies der Fall nehmen wir keinen Einfluss auf die Werte von <tt>x</tt> und <tt>y</tt>. Anderenfalls setzen wir den cursor in die Nächste Zeile (erhöhen <tt>y</tt>) und verschieben ihn zurück nach links (<tt>x = margin</tt>).
<pre class="brush: processing" dir="ltr">if (x + charWidth &gt; width - margin) {
   y = y + fontSize * 1.2;
   x = margin;
}</pre>

Im letzten Schritt verschieben wir die <tt>x</tt>-Position um die Breite des aktuellen Zeichens.
<pre class="brush: processing" dir="ltr">x += 31; // &lt;- monospaced
x += charWidth + (mouseX / 40.0);</pre>
Mit einer einheitlichen Verschiebung, unabhängig vom Zeichen, würde man eine monospaced Anmutung erhalten.
<h4>Example code</h4><pre class="brush: processing" dir="ltr">String txt = &quot;So perhaps a &ldquo;luck&rdquo; gene that somehow confers a quantum mechanical manipulation power could exist.&quot;;
PFont font;

int fontSize = 21;
int margin = 10;

void setup () {
    // Sketch initialisieren
    size (550, 220);
    smooth ();
    
    // Generiere die Schrift 'Arial' als PFont
    font = createFont (&quot;Arial&quot;, fontSize);
    // Setze die Schrift f&uuml;r alle kommenden
    // text() Aufrufe
    textFont (font);
}

void draw () {
    // Leere das Sketchfenster mit 
    // einem Grauton
    background (76, 76, 75);
    
    // Lege die Ausgangs x-Position fest
    float x = margin;
    // Lege die Ausgangs y-Position fest
    float y = height / 2 - fontSize;
    
    // Diese for-Schleife l&auml;uft durch den gesamten
    // Text; Zeichen f&uuml;r Zeichen...
    for (int i=0; i &lt; txt.length (); i++) {
        
        // W&auml;hle das aktuelle Zeichen an der Position
        // 'i' im Text aus und lege es in der 'char' 
        // Variable 'c' ab.
        char c = txt.charAt (i);
        // Ermittle die Breite dieses Schriftzeichens
        // anhand der aktuellen Schriftart und -gr&ouml;&szlig;e
        float charWidth = textWidth (c);
        

        // &Uuml;berpr&uuml;fe ob das aktuelle Zeichen ander Position
        // 'x' noch innerhalb unserer Zeichenfl&auml;che + den
        // vorher definierten Rand 'margin' w&auml;re.
        if (x + charWidth &gt; width - margin) {
            
            // Wenn nicht...
            // y: Positioniere das Zeichen in der n&auml;chsten Zeile
            y = y + fontSize * 1.2;
            // x: Setze die x-Position zur&uuml;ck
            x = margin;
        }
        
        // Berechne die F&uuml;llfarbe anhand der Position
        // innerhalb der Zeichenfl&auml;che
        fill (x*1.5, y*1.5, 255);
        
        // Stelle das Schriftzeichen dar
        text (c, x, y);
        
        // Verschiebe die x-Position f&uuml;r das n&auml;chste
        // Zeichen um die Breite von 'c' und einen 
        // von der Mausposition abh&auml;ngigen Wert
        x += charWidth + (mouseX / 40.0);
    }
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/VW96e6cKdL8" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/text:schriftzeichen-manuell-positionieren</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/text:maskierter-text"><title>Maskierter Text (text)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/bifFn5E_4S0/text:maskierter-text</link><dc:date>2012-02-27T17:49:15+0000 (UTC)</dc:date><dc:description><![CDATA[In diesem Beispiel maskieren wir einen Text mittels zwei Bildern. Zu Begin wird der Text mit weißer Füllung in das Dunkle Sketchfenter gezeichnet und dient als Ausgangspunkt. Der Aufruf von <a href="http://www.processing.org/reference/textAlign_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: textAlign()">textAlign()</a> mit <span class="constant-name">CENTER</span> und die Positionierung bei <tt>width/2</tt> und <tt>height/2</tt> zentrieren den String auf der Zeichenfläche.
<pre class="brush: processing" dir="ltr">background (76);
fill (255);
textFont (font);
textAlign (CENTER);
text (&quot;Text goes here&quot;, width/2, height/2 + 10);</pre>
Im nächsten Abschnitt kopieren wir den Inhalt des Sketchfensters in das Bild (<span class="constant-name">PI</span>mage) <tt>imgText</tt> und erzeugen ein weiteres, leeres namens <tt>imgMask</tt>. Beide Bilder haben wir damit nicht wie üblich geladen, sondern dynamisch angelegt. Ein Weg dies zu tun ist die von Processing zur Verfügung gestellte Funktion <a href="http://www.processing.org/reference/createImage_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: createImage()">createImage()</a>. Der Parameter <span class="constant-name">ARGB</span> steht für ein Bild im <span class="constant-name">RGB</span> Farbraum, welches ebenfalls Transparenz unterstützt (A = alpha).<br />
<br />
Dies waren bisher alles Vorbereitungen im <span class="function-name">setup</span><span class="function-params">()</span>. Im <span class="function-name">draw</span><span class="function-params">()</span> gilt es nun die Maske mit den Balken zu befüllen und final auf den Text anzuwenden. Durch den Aufruf der Funktion <span class="function-name">updateMask</span><span class="function-params">()</span> löschen wir zu Anfang den Inhalt des Sketchfensters und zeichnen weiß gefüllte Balken. Dieses Bild wird anschließend in die Maske kopieret und mit <a href="http://www.processing.org/reference/mask_.html" lang="en" class="processing-reference" target="_blank" title="Processing.org reference: mask()">mask()</a> auf das Bild <tt>imgText</tt> angewendet.<br />
<br />
Damit haben wir die Maske aktualisiert und alle Balken nach unten verschoben. Was nun geschieht ist der letzte Schritt. Wir zeichnen den Text auf farblich angepasstem Hintergrund:
<pre class="brush: processing" dir="ltr">background (138, 170, 178);
fill (229, 90, 38);
text (&quot;Text goes here&quot;, width/2, height/2 + 10);</pre>
Und stellen das maskierte Bild deckungsgleich dar:
<pre class="brush: processing" dir="ltr">image (imgText, 0, 0);</pre><h4>Example code</h4><pre class="brush: processing" dir="ltr">// Leere Bilder f&uuml;r Text und Maske
PImage imgText;
PImage imgMask;
// Variable f&uuml;r die Schrift
PFont font;

// H&ouml;he der Balken
int barHeight = 17;
// Verschiebung in Pixeln
float offset = 0;
// Verschiebung pro Bild
float offsetTick = 0.3;

void setup () {
  size (550, 200);
  noStroke ();
  
  // Kantengl&auml;ttung aktivieren
  smooth ();
  // Laden und Erstellen der Schrift
  font = createFont (&quot;Arial&quot;, 67);
  
  // Zeichne wei&szlig;en Text auf dunklen
  // Hintergrund in das Sketchfenster
  background (76);
  fill (255);
  textFont (font);
  textAlign (CENTER);
  text (&quot;Text goes here&quot;, width/2, height/2 + 10);
  
  // Kopiere den Inhalt des Sketchfensters in
  // das tempor&auml;re Bild 'imgText'
  imgText = createImage (width, height, ARGB);
  copySketchIntoImage (imgText);
  
  // Erstelle ein weiteres leeres Bild
  // f&uuml;r die Maske
  imgMask = createImage (width, height, ARGB);
}

void draw () {
  
  // Verschiebe die Balken weiter nach unten
  offset += offsetTick;
  if (offset &gt; barHeight * 2) {
    offset = 0;
  }
  
  // Aktualisiere die Makse mit der
  // aktuellen Verschiebung
  updateMask (offset);
  // Setze das Bild 'imgMask' als Maske
  imgText.mask (imgMask);
  
  // Zeichne die invertierte Version
  background (138, 170, 178);
  fill (229, 90, 38);
  text (&quot;Text goes here&quot;, width/2, height/2 + 10);
  
  // Zeige das maskierte Bild an
  image (imgText, 0, 0);
}

// Funktion um die Maske zu aktualisieren
void updateMask (float theOffset) {
  background (0);
  fill (255);
  for (float i=theOffset - barHeight; i &lt; height; i += barHeight * 2) {
    rect (0, i, width, barHeight);
  }
  copySketchIntoImage (imgMask);
}

// Funktion um alle Pixel des Sketchfensters
// in ein Bild zu kopieren.
void copySketchIntoImage (PImage theDestImage) {
  loadPixels ();
  theDestImage.loadPixels ();
  for (int i=0; i &lt; pixels.length; i++) {
    theDestImage.pixels[i] = pixels[i];
  }
  theDestImage.updatePixels ();
}

// Funktion um alle Pixel eines Bildes in ein
// anderes Bild zu kopieren.
void copyImage (PImage theSource, PImage theDestination) {
  theSource.loadPixels ();
  theDestination.loadPixels ();
  
  if (theSource.pixels.length != theDestination.pixels.length) {
    return;
  }
  
  for (int i=0; i &lt; theSource.pixels.length; i++) {
    theDestination.pixels[i] = theSource.pixels[i];
  }
  
  theDestination.updatePixels ();
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Steffen Fiedler (@comkee)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/bifFn5E_4S0" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/text:maskierter-text</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/audio:frequenz-gruppen-ermitteln"><title>Frequenz Gruppen ermitteln (audio)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/8tsHls745Jo/audio:frequenz-gruppen-ermitteln</link><dc:date>2012-02-06T21:55:21+0000 (UTC)</dc:date><dc:description><![CDATA[<div class="image"><a class="fancybox" href="/files/documents/b17_05_audioinput_fft.png"><img src="http://www.creativecoding.org//files/documents/b17_05_audioinput_fft.png" style="float:right;" /></a></div>
Die minim Bibliothek bietet neben dem Laden/Abspielen von Dokumenten, dem Nutzen von Audiohardware ein Paket von Werkzeugen um Klange zu erzeugen bzw. bestehendes Material auszuwerten. Eine bekannte Mehthode ist die sog. <span class="constant-name">FFT</span> (<a href="http://de.wikipedia.org/wiki/Schnelle_Fourier-Transformation" class="extern http" target="_blank">Fast Fourier Transform</a>), bei der das Frequenzspektrum in eine feste Anzahl von Frequnzbändern unterteilt wird. Durch das Auslesen dieser Bänder erhält man Aufschluss über die Verteilung von Höhen, Mitten und Tiefen in der Audiodatei.<br />
<br />
Da es bei hohen Auflösungen in den Bereichen von <span class="constant-name">1024</span>, <span class="constant-name">512</span> oder <span class="constant-name">256</span> Bändern (wie in diesem Fall) nicht zu einer Abfrage jedes Frequenzbandes kommen muss, werden diese in den meisten Fällen zu Gruppen zusammengefasst. Im folgenden Beispiel liefert die Funktion <span class="function-name">getGroup</span><span class="function-params">()</span> diese verkürzte Fassung mit einer Auflösung von <span class="constant-name">16</span> Bereichen, welche als Parameter angegeben wird. Die Anzahl der Bereich muss dabei immer ein Vielfaches von 2 sein (2, 4, 8, <span class="constant-name">16</span>, <span class="constant-name">32</span>, <span class="constant-name">64</span>, <span class="constant-name">128</span>, â&euro;¦). Innerhalb der Funktion wird ein <a href="/lesson/basics/processing/arrays#arrays" class="intern lesson">Array</a> angelegt und der Mittelwert einer jeden Frequenzgruppe berechnet, final in einem der Arrayfelder abgelegt. Nach dem Aufruf im <a href="/lesson/basics/processing/mausinteraktion#vorbereitung_fortlaufende_programme" class="intern lesson">draw()</a>, kommt es zu einer simplen Abbildung der Audiodaten um die Funktionsweise zu verdeutlichen.<h4>Example code</h4><pre class="brush: processing" dir="ltr">import ddf.minim.*;
import ddf.minim.analysis.*;
 
Minim minim;
AudioInput input;
FFT fft;

float maxSpec = 0;

void setup () {
  size(320, 240);
  noStroke ();
  
  // Audiotool-Box und Mikrofoneingang erstellen 
  // und einrichten. Die '256' bestimmen dabei die 
  // sp&Atilde;&curren;tere Aufl&Atilde;&para;sung des Spektrums.
  minim = new Minim (this);
  input = minim.getLineIn (Minim.STEREO, 256);
  // FFT-Instanz f&Atilde;&frac14;r die Spektrumsanalyse
  fft = new FFT (input.bufferSize (), 
                 input.sampleRate ());
}
 
void draw () {
  background (0);
  
  float g = 0;    // Gr&Atilde;&frac14;nwert der F&Atilde;&frac14;llfarbe
  float h = 0;    // H&Atilde;&para;he von Rechteck und Linie
  float specStep; // Breite einer horiz. Linie
  float specScale = (float) width / (fft.specSize () - 1);
  
  // Erzeugen der 'Frequenz-Gruppen' (16 Bereich)
  // m&Atilde;&para;gliche Schritte: 2-4-8-16-32-64-128
  float[] group = getGroup (16);
  
  // Zeichnen des detailierten Frequenzspektrums
  noStroke ();
  for (int i = 0; i &lt; fft.specSize (); i++) {
    g = map (fft.getBand (i), 0, maxSpec, 50, 255);
    h = map (fft.getBand (i), 0, maxSpec, 2, height);
    fill (0, g, 0);
    rect (i * specScale, height - h, specScale, h);
  }
  
  // Zeichnen der Gruppen (Linien)
  stroke (255, 255, 0, 200);
  specStep = width / group.length;
  for (int i=0; i &lt; group.length; i++) {
    h = height - map (group[i], 0, maxSpec, 0, height);
    line (i * specStep, h, (i+1) * specStep, h);
  }
}

/** 
 * Funktion fasst das vorliegende FFT-Spektrum
 * in eine durch den Parameter 'theGroupNum' 
 * festgelegte Anzahl von gleichgro&Atilde;&Yuml;en Bereichen
 * zusammen &acirc;&euro;&ldquo; und gibt deren Mittelwert zur&Atilde;&frac14;ck.
 */
float[] getGroup (int theGroupNum) {
  fft.forward (input.mix);
  
  // Leeres Array f&Atilde;&frac14;r die Gruppen erstellen
  float[] group  = new float[theGroupNum];
  // Das FFT-Spekturm hat eine Stelle mehr 
  // als beim Input definiert. (256-&gt;257).
  // Diese wird ignoriert.
  int specLimit  = fft.specSize () - 1;
  // Anzahl der Frequenzb&Atilde;&curren;nder pro Gruppe
  int groupSize = specLimit / theGroupNum;
  
  // Alle Gruppen mit einem Startwert f&Atilde;&frac14;llen
  for (int i=0; i &lt; group.length; i++) {
    group[i] = 0;
  }
  
  // F&Atilde;&frac14;r jedes FFT-Frequenz-Band
  for (int i=0; i &lt; specLimit; i++) {
    // Maximum?
    if (fft.getBand (i) &gt; maxSpec) {
      maxSpec = fft.getBand (i);
    }
    // Jedes Band einer Gruppe zuweisen
    int index = (int) Math.floor (i / groupSize);
    group[index] += fft.getBand (i);
  }
  
  // Der Wert jeder Gruppe durch die Anzahl
  // der enthaltenen B&Atilde;&curren;nder Teilen - &gt;Mittelwert
  for (int i=0; i &lt; group.length; i++) {
    group[i] /= groupSize;
  }
  // Gruppe zur&Atilde;&frac14;ck geben.
  return group;
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Jonas Loh (@ranzen)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/8tsHls745Jo" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/audio:frequenz-gruppen-ermitteln</feedburner:origLink></item><item rdf:about="http://www.creativecoding.org/example/audio:simples-spektrum-wellenform"><title>Simples Spektrum (Wellenform) (audio)</title><link>http://feedproxy.google.com/~r/cc-recentexamples/~3/Ou0zLC8k3sI/audio:simples-spektrum-wellenform</link><dc:date>2012-02-06T21:55:17+0000 (UTC)</dc:date><dc:description><![CDATA[<div class="image"><a class="fancybox" href="/files/documents/b17_04_audioinput_specturm.png"><img src="http://www.creativecoding.org//files/documents/b17_04_audioinput_specturm.png" style="float:right;" /></a></div>
Eine der bekanntesten Darstellungen von Ton und Klang ist das klassische Spekturm. In minim als <a href="http://code.compartmental.net/minim/javadoc/ddf/minim/AudioBuffer.html" class="extern http" target="_blank">AudioBuffer</a> bezeichnet, beinhaltet es ein <em>float</em> <a href="/lesson/basics/processing/arrays#arrays" class="intern lesson">Array</a> mit einem Wert pro Kanal. Die Anzal der Kanäle wird bei dem Erzeugen des <a href="http://code.compartmental.net/minim/javadoc/ddf/minim/AudioInput.html" class="extern http" target="_blank">AudioInputs</a> festgelegt. In diesem Fall unterteilen wir das Spektrum zu Beginn im <a href="/lesson/basics/processing/mausinteraktion#vorbereitung_fortlaufende_programme" class="intern lesson">setup</a>-Blocks in <span class="constant-name">96</span> Bereiche.<br />
Mit jedem Einzelbild wird eine Kopie des Buffers (toArray()) erzeugt um beim Durchlaufen des Arrays alle Einträge im Spektrum abzubilden. In der dafür benutzen <a href="/lesson/basics/processing/variablen-schleifen#for_schleife" class="intern lesson">for-Schleife</a> verbindet die Oberseite eines <a href="/lesson/basics/processing/einstieg-in-processing#rechteck" class="intern lesson">Rechtecks</a> jeweils zwei Teile des Spektrums. Neben der <tt>y</tt>-Position gibt der Mittelwert beider Kanäle die <span class="constant-name">HSB</span>-Füllfarbe an.<h4>Example code</h4><pre class="brush: processing" dir="ltr">import ddf.minim.*;

Minim minim;
AudioInput input;

float yStart = 100;
float yScale = 140;

void setup () {
  // Sketch einstellen
  size (320, 240);
  smooth();
  noStroke ();
  colorMode (HSB);
  
  // Audiotoolkit anlegen
  minim = new Minim (this);
  input = minim.getLineIn (Minim.STEREO, 96);
}

void draw () {
  background (0);
  
  // Auslesen und speichern des Spektrums
  float[] buffer = input.mix.toArray ();
  // Breite der Rechtecke berechnen
  float step = ceil ((float) width / buffer.length);
  
  // F&Atilde;&frac14;r jeden einzelnen Eintrag im Buffer wird ein 
  // Rechteck gezeichnet. Es entsteht durch das verbinden
  // zweier Buffer-Eintr&Atilde;&curren;ge. Die Schleife beginnt bei 1, 
  // jeder Eintrag wird mit seinem Vorg&Atilde;&curren;nger verbunden.
  for (int i=1; i &lt; buffer.length; i++) {
    
    // Positionen f&Atilde;&frac14;r alle 4 Punkt bestimmen
    float x1 = (i-1) * step;
    float x2 = i * step;
    float y1 = yStart + buffer[i-1] * yScale;
    float y2 = yStart + buffer[i] * yScale;
    
    // F&Atilde;&frac14;llfarbe definieren
    float h = (buffer[i-1] + buffer[i]) / 2;
    fill (h * 255, 255, 255);
    
    // Rechteck zeichnen
    beginShape (QUADS);
    vertex (x1, y1);
    vertex (x2, y2);
    vertex (x2, height);
    vertex (x1, height);
    endShape ();
  }
}</pre>]]></dc:description><dc:publisher>Studio NAND</dc:publisher><dc:creator>Jonas Loh (@ranzen)</dc:creator><dc:rights>http://creativecommons.org/licenses/by-sa/3.0/</dc:rights><description>&lt;img src="http://feeds.feedburner.com/~r/cc-recentexamples/~4/Ou0zLC8k3sI" height="1" width="1"/&gt;</description><feedburner:origLink>http://www.creativecoding.org/example/audio:simples-spektrum-wellenform</feedburner:origLink></item></rdf:RDF>
