Datenfelder (Arrays)


Processing 2.0

In Variablen kann man nicht nur einzelne Werte speichern, sondern mehrere, die ein- oder zweidimensional organisiert sind. Das nennt man dann ein – oder zweidimensionale Arrays. Sie unterscheiden sich nur wenig von „normalen“ Variablen und werden in der Form array[] (eindimensional) oder array [] [] (zweidimensional) deklariert. Der Datentyp (int, float, uws.) muss außerdem festgelegt werden.

float [] eindimensional = new float [200];

Die obige Anweisung deklariert ein eindimensionales Datenfeld mit dem Namen eindimensional, in dem 200 Werte gespeichert werden können (0-199). Aufgerufen werden die einzelnen Felder dann mit eindimensional[i], wobei i dann für eine Zahl von 0 bis 199 steht.

float[] [] zweidimensional = new float [200] [200];

Hier haben wir ein Beispiel für ein zweidimensionales Feld, das dann mit zweidimensional[i][i] mit Werten befüllt werden kann. So können die Werte dann natürlich auch wieder ausgelesen werden.

Beispiel: starte Applet

/** Copyright 2012 Thomas Koberger
*/

// https://lernprocessing.wordpress.com/
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

PImage foto;//deklariert die Variable foto;
float [] [] grau;

void setup() {
size(400, 400);
grau = new float [400] [400]; //hier wird ein zweidimensionales Array deklariert
foto = loadImage("blume.jpg");//weist der Variablen foto die datei blume.jpg zu
while(foto.width<1){} //pausiert den Sketch, bis das Bild geladen ist.
foto.loadPixels(); //sollte man aufrufen, bevor man die einzelen Pixel bearbeitet
//foto.pixels=sort(foto.pixels);//wird diese Funktion aktiviert, werden die Farben sortiert ausgegeben
for (int gridX = 0; gridX < foto.width; gridX++) {
for (int gridY = 0; gridY < foto.height; gridY++) {
// überträgt die Farbinfo eines Pixels auf die Variable farbe
//color farbe = foto.pixels[gridY*foto.width+gridX];
color farbe = foto.get(gridX,gridY);
// wandelt die Farbinfo in einen Grauwert um
float grauwert =red(farbe)*0.222+green(farbe)*0.707+blue(farbe)*0.071;
// println(grauwert);
grau [gridX] [gridY] = grauwert;//speichert den Grauwert in unser Array grau
}
}
}

void draw() {
background(0);
//image(foto,0,0);// gibt einen netten Überlagerungseffekt
//jetzt wird nur für jedes 10 Pixel der Helligkeitswert ausgelesen.
for (int gridX = 0; gridX < foto.width; gridX+=10) {
for (int gridY = 0; gridY < foto.height; gridY+=10) {
fill(grau [gridX] [gridY]);//gibt den Grauwert aus unserem Array aus
ellipse (gridX,gridY,9,9);
}
}
}

Dieses Beispiel liest die Farbinformationen jedes Pixels eines Bildes aus und wandelt sie in Grauwerte um. Dann werden Ellipsen mit den Grauwerten gezeichnet.

Arrays können durch Funktionen manipuliert werden.

Array-A= append(Array-A, Wert) // hängt ein Element an
Array-A= shorten(Array-A) // eliminiert das letzte Element
arrayCopy(Array-A,Array-B) // kopiert den Inhalt von Array A nach Array-B
Array-A= reverse(Array-A) // kehrt die Reihenfolge der Elemente um
Array-A= sort(Array-A) //sortiert die Elemente der Größe nach
Array-A= concat(Array-A, Array-B) // hängt Array-B an Array-A an

Aufgabe: Erweitere das folgende Programm so, dass es:

  1. ein Element an A anhängt
  2. 2 Elemente kürzt
  3. die Elemente in ein neues Array B kopiert
  4. und die Elemente in umgekehrter Reihenfolge ausgibt.
int [] A = {1, 2, 3, 4, 5, 6};
for (int i=0; i<A.length; i++) { //*.length gibt die Anzahl der Elemente eines Arrays zurück (int)
 println(A[i]);
}

Kleinsten und größten Wert eines Arrays ermitteln:

Zwei kleine Funktionen, die diese Aufgaben erledigen.

float getMaxValue ( float[] values) {
Arrays.sort(values);
return values[values.length-1];
}

Und analog dazu:

float getMinValue ( float[] values) {
Arrays.sort(values);
return values[0];
}
Advertisements

9 Kommentare

  1. Pingback: Processing – Über dieses Weblog « processing – tutorial

  2. Pingback: Lesen und schreiben von Textdateien mit Processing « processing – tutorial

  3. Pingback: Korruption in der Demokratie « processing – tutorial

  4. Pingback: Array Lists « processing – tutorial

  5. Pingback: Fotos « processing – tutorial

  6. Mag. Thomas Koberger

    Reblogged this on processing – tutorial und kommentierte:

    updated

  7. Pingback: Kinect Einstieg « processing – tutorial

  8. Hello! Would you mind if I share your blog with my twitter group?

    There’s a lot of folks that I think would really appreciate your content. Please let me know. Thank you

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

%d Bloggern gefällt das: