Das Bild als Gitter

Halte dein Handy nah genug an ein Foto, und irgendwann siehst du keine Kabel und keine LED mehr, sondern Kästchen. Genau so liegt ein Bild im Speicher: als Tabelle aus Zahlen, Zeile für Zeile.

Das Gitter anfassen

Der Ausschnitt unten zeigt zehn Spalten und acht Zeilen aus dem echten Foto – jede Kachel ein Bildpunkt, jede Zahl eine Helligkeit zwischen 0 und 255. Fahre mit der Maus über das Gitter: Zeile und Spalte des Bildpunkts werden markiert, und die Zeile darunter zeigt die Java-Schreibweise bild[zeile][spalte]. Ein Klick hält den Bildpunkt fest, ein zweiter Klick gibt ihn wieder frei. Was diese Schreibweise genau bedeutet, klären die nächsten Abschnitte.

Probiere danach die Filter aus. Jeder wendet seine Regel – angezeigt als Java-Code – auf jeden einzelnen Bildpunkt an.

Eine Zeile kennst du schon

Nimm dir nur die oberste Zeile des Gitters vor. Das sind zehn Zahlen nebeneinander, also ein ganz gewöhnliches eindimensionales Feld:

int[] zeile0 = {64, 82, 240, 240, 94, 189, 73, 69, 100, 76};

zeile0[2] ist 240, zeile0.length ist 10. Mit einer Schleife kommst du an jeden Wert dieser Zeile heran.

Das Gitter hat aber acht Zeilen, das echte Foto sogar 72. Acht Variablen zeile0 bis zeile7 anzulegen wäre umständlich, und über acht einzelne Variablen kann keine Schleife laufen. Dieses Problem kennst du schon: Statt vieler einzelner Zahlen hast du damals ein Feld mit Zahlen angelegt. Hier geht es genauso, nur legst du statt der Zahlen die Zeilen in ein Feld.

Ein Feld von Feldern

Ein kleines Bild mit zwei Zeilen und drei Spalten sieht in Java so aus:

int[][] bild = {
    {20, 80, 240},
    {50, 120, 200}
};

Lies den Typ int[][] von links nach rechts als „ein Feld, dessen Einträge int[] sind“. Das äußere Feld hat zwei Einträge, einen für jede Zeile. Jeder dieser Einträge ist wieder ein Feld, und zwar eines mit drei Zahlen.

Daraus folgt, wie man auf einen einzelnen Wert zugreift, nämlich in zwei Schritten:

zeile.length   = 3
zeile[2]       = 200
bild[1][2]     = 200
bild[0][1]     = 80
bild.length    = 2
bild[0].length = 3

Wie das Gitter im Speicher liegt

Die Tabellenform ist eine Vorstellung, die beim Programmieren hilft. Im Speicher liegt das Gitter aber anders: Das äußere Feld enthält keine Zahlen, sondern Verweise auf die Zeilen. Jede Zeile ist ein eigenes Feldobjekt.

Das Diagramm zeigt bild aus dem Programm oben. Bearbeite danach die beiden Schritte:

1. int[] zeile = bild[1]; Trage ein, worauf zeile danach verweist.
2. zeile[2] = 0; Ändere den Wert, der sich dadurch ändert.

Startmission: Im Gitter zurechtfinden

Bearbeite jetzt die Stationen. Du brauchst noch keinen Code zu schreiben, nur zu lesen: Du findest Bildpunkte, zählst Zeilen und Spalten, malst aus, was ein Programm in ein Gitter schreibt, und setzt am Ende eine geschachtelte Schleife zusammen. Wenn etwas noch nicht stimmt, bekommst du direkt eine Erklärung und einen neuen Versuch.

Das Foto untersuchen

Das echte Foto ist dasselbe wie das kleine bild, nur größer. Das Objekt foto liefert es dir als Graustufen: eine Zahl je Bildpunkt, 0 ist schwarz und 255 ist weiß.

grau
       Spalte 0    1    2   …   95
Zeile 0  ┌────┬────┬────┬───┬────┐
         │ 64 │ 66 │ 71 │ … │ 76 │   ← grau[0] ist ein int[] der Länge 96
Zeile 1  ├────┼────┼────┼───┼────┤
         │ 64 │ 69 │ 70 │ … │ 76 │
   …     ├────┼────┼────┼───┼────┤
Zeile 71 │101 │100 │100 │ … │ 25 │
         └────┴────┴────┴───┴────┘

IO.println("Mitte: " + grau[36][48]);

Jeden Bildpunkt einmal anfassen

Um eine einzelne Zeile zu durchlaufen, brauchst du eine Schleife, so wie bei jedem eindimensionalen Feld. Um alle Zeilen zu durchlaufen, setzt du um diese Schleife eine zweite: Die äußere holt eine Zeile nach der anderen, die innere läuft durch die geholte Zeile.

for (int zeile = 0; zeile < grau.length; zeile++) {
    int[] reihe = grau[zeile];                     // die ganze Zeile, ein int[]
    for (int spalte = 0; spalte < reihe.length; spalte++) {
        // reihe[spalte] ist dasselbe wie grau[zeile][spalte]
    }
}

Die Hilfsvariable reihe zeigt, was passiert. Man lässt sie meistens weg und schreibt gleich grau[zeile][spalte]. Diese Form steht in fast jedem Filter des Projekts:

for (int zeile = 0; zeile < grau.length; zeile++) {
    for (int spalte = 0; spalte < grau[zeile].length; spalte++) {
        // hier steht grau[zeile][spalte] zur Verfügung
    }
}

Aufgabe 1: Wie hell ist das Bild?

int summe = 0;
for (int i = 0; i < werte.length; i++) {
    summe = summe + werte[i];
}

int summe = 0;
for (int zeile = 0; zeile < pGrau.length; zeile++) {
    for (int spalte = 0; spalte < pGrau[zeile].length; spalte++) {
        summe = summe + pGrau[zeile][spalte];
    }
}
return summe / ???;

Aufgabe 2: Wo ist der hellste Punkt?

int besterWert = pGrau[0][0];
int besteZeile = 0;
int besteSpalte = 0;
// … in den Schleifen: ist pGrau[zeile][spalte] größer, alle drei aktualisieren

Zum Weiterdenken