Schlagwort: Informatik

Via Twitter auf diese Anregung gestoßen, von dort zu dieser ausführlichen und sehr hilfreichen Princeton-Programmieraufgabe geleitet worden, und am Ende einfach Wikipedia dazu gelesen, wo man das schön interaktiv ausprobieren kann. Natürlich zum Lernen gleich nachprogrammiert und Blogpost daraus gemacht, damit es sich lohnt und ich es wirklich verstehe. Aber man kann statt dessen auch einfach Wikipedia lesen, da steht das auch alles.

Es geht um einen gar nicht mal so alten Algorithmus zur Bildbearbeitung. Nehmen wir mal dieses Bild, das wir bearbeiten wollen:

Da sieht man sechs Tiere, das Bild ist 700 Pixel breit, und wenn man nur 350 Pixel Platz hat für ein Bild, dann kann man es entweder verkleinern (alles wird klein), zuschneiden (aber dann fehlen Tierteile) oder zusammenquetschen (aber dann sieht alles so schmal aus). Eigentlich möchte man vielleicht, dass die Tiere einfach näher bei einander wären, mit weniger Grün dazwischen, davon gibt es eh genug.

Und das kann der Seam-Carving-Algorithmus. Aus jeder Zeile des Bildes soll erst einmal ein Pixel verschwinden, dann ist das Bild einen Pixel schmaler. Dabei wird zuerst für jeden Pixel bestimmt, wie wichtig er ist. (Zu den Details später.) Die Wichtigkeit der Pixel sieht man hier:

Wenn man in jeder Zeile den unwichtigsten Pixel entfernt, und das alles 350 mal wiederholt, kommt leider nicht ganz das heraus, was man möchte:

Man sieht, dass die Bildpixel, die zu den wichtigen Elementen gehören (den Tieren), noch alle vorhanden sind und demnach aus jeder Zeile viele – nämlich 350 – zumeist grüne, also tatsächlich eher unwichtige Pixel verschwunden sind. Aber das Bild ist verzerrt – aus der ersten Zeile sind vielleicht Pixel aus der linken Hälfte verschwunden, danach welche aus der rechten, dann immer wieder abwechselnd. Hier sind die unwichtigsten Pixel des ersten Durchgangs rosa markiert:

Man sieht, eher sprunghaft. (Dass sie im mittleren Bereich halbwegs zusammenhängen, ist Zufall und passt für mein Beispiel gar nicht so.)

Abhilfe schafft das seam carving. Seam heißt hier so viel wie Ader, und zwar die aus dem Bergbau. Man beginnt mit dem unwichtigsten Pixel in der ersten Zeile und bahnt sich von diesem aus einen Weg nach unten, wobei man immer nur die Wahl hat zwischen dem Pixel unmittelbar darunter oder dem links oder rechts davon. Das macht man so, dass man ganz unten den minimalen aller möglichen derartigen Wege hat. (Wie man das macht: später.) Dann kriegt man beim ersten Durchgang diese Ader ganz rechts im Bild:

Wenn man alles rechts der rosa Linie einen Pixel nach links verschiebt, fällt das sehr viel weniger auf, als wenn man das bei den versprengten rosa Punkten oben machen würde. Wiederholt man das 350 mal, kommt folgendes Bild heraus:

Die Proportionen der Tiere sind größtenteils erhalten, obwohl das Bild nur halb so breit ist. Nur die Kuh rechts unten ist schmaler, aber nicht am Kopf, so dass es wenig auffällt.

Ähnlich lässt sich diese Schafherde zusammentreiben:

Halb so breit:

Ich musste ein bisschen suchen, bis ich geeignete Bilder zum Demonstrieren fand. Sinnvoll ist das, wenn mindestens am rechten und am linken Bildrand Objekte sind, die sich vom Rest abheben, die also beim Ergebnis dabei sein sollen, und wenn dazwischen neben eventuellen anderen Objekten viel gleichartige Fläche ist – Himmel, Wasser, Wiese. Oft ist der Algorithmus weniger erfolgreich. Hier ein Original:

Und die wieder um 50% verschmälerte Fassung, was zugegeben schon auch recht viel ist. Die Proportionen sind weitgehend okay, aber es fehlen schlicht Stellen:

Natürlich gibt es noch Möglichkeiten, den Algorithmus schneller oder besser zu machen, aber mir reicht das erst einmal.

Technische Details

Drei Probleme habe ich oben allenfalls angedeutet: 1. Wie findet man heraus, welcher Pixel wichtig ist und welcher nicht? 2. Wie findet man so einen seam, einen relativ unwichtigen vertikalen Pfad? Und: 3. Wie entferne ich diesen Pfad aus dem Bild? Das erste Problem ist das interessante, und die anderen beiden sind programmiertechnisch fisseliger, als ich erwartet hatte.

1. Energie/Wichtigkeit eines Pixels

Gespeichert habe ich die Energien in einem eindimensionalen int-Array der Länge Bildgröße*Bildbreite. Wahrscheinlich gibt es mehrere Möglichkeiten, die Energie eines Pixels (heißt in der Anleitung, die ich verwendet habe, so, energy) zu berechnen. Die oben verlinkte Anleitung macht das so:

1. Berechne die Rot-Differenz zwischen dem linken und dem rechten Nachbarpixel des Pixels, dessen Energie bestimmt werden soll.
   In Java bestimmt man die rgb-Anteile eines Pixels (x,y) des BufferedImage image so:
   int r1 = new Color(image.getRGB(x,y)).getRed();
int g1 = new Color(image.getRGB(x,y)).getGreen();
int b1 = new Color(image.getRGB(x,y)).getBlue();
   Natürlich ist es umständlich, aus dem mit getRGB erhaltenen int-Wert erst wieder eine Farbe machen zu müssen, um sich daraus dann wieder mit getRed() den Rotwert geben zu lassen. Das geht mit Bitmanipulation schneller, aber das haben wir in der Schule noch nicht.
2. Quadriere diesen Rot-Unterschied.
3. Mache das gleiche für die Unterschiede bei den Grün- und Blau-Anteilen.
4. Wiederhole das alles für die Unterschiede zwischen den Pixeln über und unter dem Pixel, dessen Energie bestimmt werden soll.
5. Addiere diese sechs Quadrate. Das ist die Energie!
6. Randpixel: Die linke Spalte hat die rechte als linken Nachbarn, die oberste Zeile hat die unterste als oberen Nachbarn, und jeweils umgekehrt. Alle Pixel haben also zwei horizontale und zwei vertikale Nachbarn.

2. Finden eines minimalen Pfades

Auch dafür gibt es viele verschiedene Möglichkeiten, die aber natürlich alle zum selben Ergebnis führen. Ich habe das, der Anleitung folgend, so gemacht. Gespeichert wird der (vertikale) Pfad in einem eindimensionalen int-Array der Länge Bildhöhe.

Erster Teil, Anpassung der Energiewerte:

1. Ändere nichts an den Energiewerten der Pixel in der ersten Zeile.
2. Betrachte für jeden Pixel der Zeile darunter die zwei bis drei oberen Nachbarn (Randpixel haben hier nur zwei obere Nachbarn). Addiere den kleinsten der zwei oder drei Energiewerte zum eigenen Energiewert.
3. Wiederhole das für alle Zeilen einschließlich der letzten.

Zweiter Teil, Speichern des Pfades:

1. Suche in der untersten Zeile den niedrigsten Energiewert. Das ist das letzte Element des Pfades.
2. Suche in den zwei bis drei oberen Nachbarn den mit dem niedrigsten Energiewert. Der ist dann das vorletzte Element des Pfades.
3. Wiederhole das mit allen Zeilen, von unten nach oben immer das Element mit dem niedrigsten Energiewert auswählen und da weitermachen.

3. Entfernen eines Pfades

1. Erzeuge ein neues leeres Bild, um 1 Pixel schmäler als das vorhergehende.
2. Gehe das Originalbild zeilenweise durch.
3. Kopiere jeweils alle Pixel links des Pfades vom alten in das neue Bild.
4. Verschiebe alle Pixel rechts des Pfades im alten Bild um 1 nach links im neuen Bild.

Das wird vielleicht etwas klarer bei der Java-Implementierung.

Java-Umsetzung

Attribute und einfache Methoden der Klasse SeamCarver:

import java.awt.image.BufferedImage;
import java.awt.Color;
 
public class SeamCarver {
  BufferedImage image;
  int [] energy;
  int [] seam;
  int width;
  int height;
 
  public SeamCarver(BufferedImage img){ setImage(img);}               
  public SeamCarver(){}               
  public void setImage(BufferedImage img) { 
    image = img; 
    width=image.getWidth();
    height=image.getHeight();
  }
  public BufferedImage getImage() { return image; }
}

Höhe und Breite des Bildes brauche ich so oft, dass ich sie als Attribute speichere. Die Energie könnte ich auch in einem zweidimensionalen Array speichern, aber erstens habe ich das Projekt mit Processing angefangen, wo die Bildpixel als eindimensionales Array bearbeitet werden und ein entsprechendes Energy-Feld nahe liegt; außerdem weiß ich nicht, ob sich meine Schüler und Schülerinnen mit zweidimensionalen Arrays zu schwer tun, und drittens sind die Arrays in Java ja gar nicht wirklich zweidimensional.

Die von außen hauptsächlich aufzurufende Methode ist die hier:

public void carveVertical(int number) {
  for (int i=0; i<number; i++) {
    setEnergy();
    findVerticalSeam();
    removeVerticalSeam();
  }
}

Dann kann man sich mit getImage() das neue Bild geben lassen. Die kniffligen Methoden sind die hier:

void setEnergy(); //ruft fuer alle Pixel die beiden calculateEnergy-Methoden auf und fuellt das energy-Array
void findVerticalSeam(); //fuellt das seam-Array von hinten nach vorn mit den x-Positionen der entsprechenden Pixel
void removeVerticalSeam(); //ersetzt das alte Bild durch ein neues, schmaeleres
int calculateEnergyStart(int x, int y); //berechnet den Energiewert anhand der Differenzen der vier Nachbarpixel 
int calculateEnergyChanged(int x, int y); //aendert den Energiewert anhand der zwei oder drei oberen Nachbarpixel

Dazu kommen noch folgende Hilfsmethoden:

void paintVerticalSeam(); //malt einen rosa Strich, wo der seam ist 
BufferedImage getEnergyImage(); //erzeugt ein neues Bild mit Grauwerten, der Energie an dieser Position entsprechend
int energyToColor(int energyValue); //Hilfsmethode, um Energiewert in einen Grauton umzuwandeln
void printSeam(); //zum Debuggen und Testen
void printEnergy(); //zum Debuggen und Testen

Sehr lustig finde ich dabei, wie ich mich anstelle, wenn es gilt, Funktionen herausfinden. Das Hinundherrechnen mit dem eindimensionalen Energie-Array und der zweidimensionales Ansprache des Bildes ist ein wenig umständlich.

Was man noch machen könnte

Methoden, um horizontale Pfade geringster Energie zu finden und zu entfernen. Methoden, um vertikale oder horizontale Pfade einzufügen, um das Bild dezent zu vergrößern.

Kann ich das mal mit Schülern und Schülerinnen machen? Ich schwanke immer: Wenn ich zu viel vorgebe, wird die Arbeit zu kleinschrittig und man interessiert sich nicht mehr für den Zusammenhang; aber vorgeben muss ich viel. Vielleicht arbeitsteilig die Methoden machen lassen? Dazu ordentliche Testklassen mitgeben.

Ich entschuldige mich dafür, dass ich das hier schreibe, weil es dazu so viel schon im Web gibt, und ich alles, was ich dazu wissen muss, in wenigen Minuten gefunden habe. Aber mein Blog ist ja auch Archiv.

Automatische Textproduktion ist wohl gerade ein Thema. Manche Leute haben Angst vor „social bots“, kleinen Programmen, die selbstständig und automatisch Nachrichten etwa bei Twitter verfassen, die klingen, als wären sie von einem Menschen geschrieben, und die zur politischen Einflussnahmen genutzt werden können. Anderswo heißt es, dass diese Angst völlig unbegründet ist, weil es solche Programme in der freien Wildbahn gar nicht gibt. Im Guardian stand neulich etwas über ein Programm, das so gut künstlichen Text (Sachtext oder fiktional) erzeugt, dass es nicht veröffentlicht wird.

Darum geht es heute nicht, sondern um eine ganz simple Methode, Text zu generieren, der nur auf den allerersten Blick natürlich wirkt, und auf schon auf den zweiten hofft man, dass vielleicht irgendwas ein bisschen Sinn macht, und beim dritten gibt man auf. Hier zwei Beispiele:

vollen Backen verzehren und mir antwortete:—ich fand ich mich auf mein Lieber, laß uns so schwach, alles Gewehr geht vorbei wie er gewartet, hätte mir mit mir selbst. Und da standen um mich, ob täuschende Geister um zweimal im Kreise seiner Ehren und meinen Sinnen, und da—wenn ich solle mit einer bräunlichen Farbe war, als das nicht zu rauben, das
(Goethe)

asked. They sat in the shadow the leaves.“ „Good night,“ the same.“ „You do not wish he likes it.“ „He’s lonely. I know.“ „I want to be unjust. He should have everything I have everything I have killed himself last week,“ he continued the wind. A clean, well-lighted cafe was not lonely. I’m not wish he said. Turning off the
(Hemingway)

Wie das geht: Man füttert den Algorithmus mit einem mehr oder weniger kurzen Text. Das folgende schöne Beispiel habe ich von dieser Seite geklaut, die das Thema für die Sprache Golang betrachtet:

I am not a number. I am a free man.

Dann geht der Algorithmus den Text Wort für Wort durch und legt für jedes Wort eine Liste an, die die im Text vorkommenden Folgewörter enthält. Für das Beispiel sieht das so aus:

I [ am am ]
am [ not a ]
not [ a ]
a [ number free ]
number. [ I ]
free [ man. ]
man. [ ]

Nach dem „I“ steht zweimal „am“, weil das Wort „I“ zweimal von „am“ gefolgt wird und sonst von nichts. Nach „man.“ steht nichts, weil im Ausgangstext nach diesem Wort nichts anderes mehr kommt. Bei längeren Texten ist das unwahrscheinlicher. Und dann nimmt man ein zufällig ausgewähltes Wort aus dieser Sammlung (oder, wie im folgenden Beispiel, man fängt gleich mit „I“ an) und wählt aus der Liste der Folgewörter zufällig eines aus. Und dann macht man mit diesem Folgewort weiter, sucht sich einen von dessen Nachfolgern aus, und so weiter, bis entweder ein Wort kommt, das keinen Nachfolger hat (selten, eher bei kurzen Eingabetexten) oder bis man die gewünschte Wortzahl zusammen hat. Heraus kommen dann zum Beispiel solche Texte:

I am a free man.
I am a number. I am not a free man.
I am a number. I am a free man.
I am not a free man.
I am not a number. I am a number. I am not a number. I am a free man.
I am not a number. I am not a free man.
I am not a number. I am a free man.
I am a number. I am a number. I am a free man.
I am a number. I am a number. I am not a free man.
I am not a number. I am not a number. I am not a free man.

Nach „man.“ hören die Texte jeweils auf – klar, da geht es nicht weiter. Nach „a“ kommt mit gleicher Wahrscheinlichkeit entweder „number“ oder „free“. Nach „I“ kommt mit einer Wahrscheinlichkeit von 1 „am“. (Tatsächlich wäre es vielleicht sauber, jede Instanz eines Folgewort nur einmal in einer Liste zu speichern, zusammen mit der relativen Wahrscheinlichkeit, wobei die Wahrscheinlichkeiten aller Wörter sich dabei zu 1 summieren müssten. Aber bei relativ kleinen Texten ist das so einfacher.)

Für Hemingways „A clean, well-lighted place“ sieht ein Teil des Wörterbuchs übrigens so aus:

Hail [ nothing ]
He [ would disliked smiled was was did can has drinks might sat put should ]
I [ am am have have." am wish have never should know." never ]
I'm [ not ]
In [ the ]
It [ was was was was was is is was ]
Look [ at ]
Many [ must ]
Nor [ can ]
Now, [ without ]
Our [ nada ]

Weil das so viele Wörter sind, gehen wir erst einmal zurück zu unserem kurzen Ausgangstext. Man kann die Information in dem Wörterbuch auch als Graph angeben:

Dabei ist jedes Wort, jeder Lexikoneintrag, ein Zustand des Systems, dargestellt als ein Knoten, verbunden mit den möglichen Folgewörtern durch gerichtete Kanten, die durch eine Gewichtung ausgezeichnet sind, die die Wahrscheinlichkeit des Übergangs angibt – es muss lediglich gelten, dass die Summe aller Kantengewichte, die von einem Knoten ausgehen, 1 ist.

Klar, schöner wäre es, wenn man von „free“ auch noch mit einer gewissen Wahrscheinlichkeit zu „number“ käme. Aber das kommt im – zugegeben sehr kurzen – Ausgangstext nun mal nicht vor. Eine Markow-Kette wäre das dann trotzdem.

Man kann die Übergangswahrscheinlichkeiten der Zustände auch als Tabelle angeben:

Was eine Markow-Kette nun genau ist, muss ein Mathematiker erklären. Hier geht es nur um die einfachen Fälle, mit endlich vielen Zuständen, und Übergangswahrscheinlichkeiten, die nur vom letzten Zustand abhängen. Man könnte ja auch die zwei vorhergehenden Wörter heranziehen, um das Folgewort zu ermitteln.

Markow-Ketten eignen sich wohl zur Simulation von Systemen, die sich damit gut simulieren lassen. :-) Wenn man für ein Computerspiel zum Beispiel zufälliges Wetter braucht, kann man entweder jeden Tag neues Wetter auswürfeln mit 50% Chance für Sonne oder Regen, oder man erstellt eine Markow-Kette, wo man vom Zustand Sonne aus am nächsten Tag mit 80% Wahrscheinlichkeit wieder im Sonnenzustand landet, aber mit 20% bei Regen – und der Zustand Regen funktioniert ähnlich. Dann ändert sich das Wetter auch ab und zu, und es gibt eben so viele Sommer- wie Regentage, aber es gibt längere Folgen und seltenere Wechsel.

Zum Schluss noch ein Auszug aus der modifizierten Schulordnung für Gymnasien in Bayern:

zugelassener Hilfsmittel bei ausreichendem Leistungsstand in Latein mindestens zwei Ausbildungsabschnitten 12/1 ist, abgesehen vom Kurzreferat; 2. Nach Beginn der Gesamtnote „ausreichend“ oder staatlich genehmigten Ersatzschule abzunehmen, wenn nicht auf dem Abschlusszeugnis die Fortsetzung eines schulärztlichen Zeugnisses eine mindestens 1 und Schüler, die nach § 2 Satz 2 Satz 2, der mündlichen Prüfungen abgelegt und Gesellschaft. (3) Für Schulaufgaben in eine Änderung der Nachprüfung erfolgreich unterzogen haben, erhalten sie oder des Ausbildungsabschnitts 12/1 oder dem doppelt gewichteten Durchschnitt der Schulleiter kann für den Fächern Deutsch, Mathematik (Abiturprüfungsfächer 1 und 3. am Kolleg kann bei der Jahrgangsstufe mit der Übertritt in einem vom Staatsministerium gesondert fest. 2Schülerinnen und das Vorrücken gefährdet, so bemühen sich auf Ausschluss von Leistungsnachweisen und Recht sowie in der Hauptprüfung dauern in Anlage 9 nach dem gewählten Ausbildungsrichtung hat die zweite Fremdsprache 1 Punkt bewertet. 8. über das Ziel der Schulleiter festzusetzenden Frist, die sich auf einem Schüler während der Realschule, die Belegung und Worten) ausgedrückt, die Punktzahl der fünf Abiturprüfungsfächern wird ermittelt, indem die ihnen die Schule wird in Satz 1 genannte Zeitpunkt. (4) Während des Gymnasiums sind ferner am Musischen Gymnasien als Abiturprüfungsfächer ist und welche beiden Fächer (Abiturprüfungsfächer 4 erreicht haben sich die auch darauf

Links:

• Schöne Seite, bei der man mit einfachen Markow-Ketten in Echtzeit experimentieren kann: http://setosa.io/ev/markov-chains/
• Schöne Erklärung, wie das mit der Textgenerierung geht, zusammen mit mehr oder weniger fertigem Python-Code: http://www.cyber-omelette.com/2017/01/markov.html

Ich habe hier schon schon einmal das Spiel „Keep Talking and Nobody Explodes“ vorgestellt. Ein Spieler oder eine Spielerin sitzt dabei am Rechner vor einem virtuellen Bombenkoffer, den es zu entschärfen gilt, und zwar alle drei (oder mehr) Module am Koffer. Eines davon ist das Drahtdurchschneiden, das man aus Filmen kennt: Es gibt eine Reihe von farbigen Drähten, die man in bestimmter Reihenfolge durchschneiden muss. Nur welche Reihenfolge?

Die anderen Spieler und Spielerinnen, und nur die, haben alle das hochkomplizierte Bombenentschärf-Handbuch vor sich liegen, sehen aber nicht den Bombenkoffer. Also muss man miteinander reden – es ist ein Dialogspiel: Wie viele Drähte? Welche Farben haben sie? Welche anderen Merkmale gibt es an dem Modul oder am ganzen Koffer? Davon hängt dann die Lösung ab.

So etwas habe ich in grob vereinfachter Form für meine Informatikklasse programmiert. Allerdings habe ich das ganze „Rätselkoffer“ genannt – das gibt mehr Spielraum für die verschiedenen Module und ist nicht ganz so gewalttätig.

Das Drahtdurchschneide-Grafikmodul sieht zum Beispiel so aus (eigentlich nur der gelb hinterlegte Bereich):

Das sind einfach sieben recht schmale und hohe Knöpfe oben und ein paar Ausgabefelder unten. Für die Knöpfe gibt es Methoden, um eine beliebige Grafik als Hintergrund zu setzen, und vorgefertigt sind Grafiken mit Drähten in verschiedenen Farben, durchgeschnitten oder ganz.

Eine andere Modul-Grafik (ein Schülerwunsch) sieht so aus: Drei quadratische Knöpfe oben, ein breiter, niedrigerer Knopf darunter. Die Knöpfe oben kann man zum Beispiel mit solchen Bildern füllen:

Was man mit den Knöpfen beziehungsweise dem ganzen grafischen Block macht, bleibt den Schülern und Schülerinnen überlassen. Tatsächlich besteht jedes Rätselmodul aus zwei Objekten, die in den Klassen ModulGUI und Modul beziehungsweise Unterklassen davon beschrieben werden: ModulGUI ist lediglich die Grafik des aktuellen Elements; die Unterklassen dazu stelle ich zur Verfügung. (Denn Grafikprogrammierung in Java ist einfach zu fisselig, wenn man sie noch nie gemacht hat, auch wenn die Elemente ja nur aus verschieden großen Buttons und Ein- und Ausgabeflächen bestehen.) Zu jedem ModulGUI-Objekt gehört ein Modul-Objekt, das die Spiellogik und Steuerung übernimmt. Und eben dieses (beziehungsweise die Unterklassen dazu) wird von den Schülern und Schülerinnen programmiert: Im Beispiel ist das die Klasse Demo:

Die Demo-Klasse legt erstens ein WireGUI-Objekt an, um diesem Nachrichten zu schicken, wie welcher Knopf aussehen soll. Und zweitens macht sie sich zur Unterklasse von Modul, damit das WireGUI-Objekt seinerseits Nachrichten – darüber, welche Knöpfe gedrückt werden – an das Demo-Objekt, also die Steuerung, schicken kann.

So sieht eine zu programmierende Klasse dann aus:

public class Demo extends Modul 
{
    WireGUI gui;
 
    public Demo() {
        gui = new WireGUI();
        gui.setSteuerung(this);
        gui.setButtonImage(1, "drahtRot.png");
    }
 
    @Override
    public WireGUI getGUI() { 
        return gui; 
    }
 
    @Override
    public void empfangeKnopfdruck(int knopfnr) {
        if (knopfnr==1) { gui.setButtonImage(1, "drahtRotCut.png"); }
    }
}

So sieht das alles in BlueJ aus:

An der linken Seite sieht man einige mögliche Grafik-Unterklassen. An der unteren Seite sind die Steuerung-Unterklassen, also die von den Schülern und Schülerinnen zu programmierenden. Das obere Drittel ist technischer Kram, ausgebreitet auf verschiedene Klasse zur leichteren Wartung.

Könnte man in sie hineinblicken, wirkten sie vielleicht ein wenig umständlich, und das liegt daran, dass die Grafikbibliothek JavaFX und BlueJ nicht optimal zusammenarbeiten. Wenn ich Objekte in der Objektleiste unten haben und ansprechen können möchte, muss ich tricksen. (Der JavaFX-Thread lässt sich nicht gerne von außen unterbrechen, will heißen: durch manuelle Methodenaufrufe von BlueJ aus.) Und so gibt es mehre Möglichkeiten, etwas zu sehen zu kriegen:

• in der Main-Klasse die statische Methode launch(String[] args) aufrufen, die den JavaFX-Thread startet
• ein Main-Objekt anlegen oder eine andere statische Methode darin aufrufen, dann wird die JavaFX-Grafik gekapselt in einem JavaSwing-JFrame und ist damit für Objekte in der Objektbank zugänglich (tatsächlich gibt es noch einen Schönheitsfehler dabei, anderes Thema)
• ein Objekt einer Modul-Unterklasse anlegen, das sich eine ModulGUI-erzeugt, das letztlich die JFrame-Methode der Main-Klasse aufruft (Vorteil: man kann die Methode der Klasse manuell aufrufen und testen, wenn sie den JavaFX-Thread beeinflussen, muss man aber Umstände machen)
• ein Objekt einer ModulGUI-Unterklasse anlegen, das sich eine Dummy-Steuerung gibt, die letztlich die JFrame-Methode der Main-Klasse aufruft (Vorteil: wie oben) – Ziel dieser letzten beiden Konstruktionen: Die Schüler und Schülerinnen sollen einfach wie gewohnt Objekte ihrer Klassen erzeugen können, deren Oberklassen sich dann darum kümmern, dass Grafik hergestellt wird

JavaFX bietet einige grafische Elemente, mit denen man so ein Rätselmodul aufpeppen kann. Man kann sie auch alle leicht vergrößern, verkleinen, drehen, sich bewegen lassen:

Das Projekt befindet sich noch in einem Rohstadium. Ich weiß noch nicht, wie ich die einzelnen Module am besten zusammenfügen soll. Soll das Spiel aus sein, wenn man ein Modul vergeigt? Oder wird das dann einfach beendet und gesperrt und man kriegt Punktabzug? Soll es einen globalen Timer geben? Vorläufig habe ich ein Modul als Startseite, über das man auf andere, zufällig ausgewählte Module gelangt, von denen aus kann man zurück, wenn man das will:

Einsatz in der Schule: Mir gefällt die Idee, dass jedes Programmierteam ein Modul erarbeitet, die danach zu einem Spiel zusammengetragen werden. Viel müssen die Schüler und Schülerinnen eigentlich nicht können: Ein Objekt erzeugen und in einem Attribut speichern, Methoden des Objekts aufrufen, eine Unterklasse anlegen, eine Methode implementieren void empfangeKnopfdruck(int knopfnummer) – und vermutlich bedingte Anweisungen, um das sinnvoll machen zu können. Trotzdem war ich zu früh dran mit dem Ausprobieren mit meiner Klasse; das erfordert halt doch mehr Abstraktionsvermögen und Programmiererfahrung, als man meint. Inzwischen hat die Klasse einfache Zustandsautomaten programmiert und ist mit if und if else vertrauter; vielleicht komme ich noch einmal darauf zurück. Die JavaFX-Grafikklassen erstelle ich übrigens mit dem Java-Editor, sie erfordern dann nur wenig Anpassung, um sie zu ModulGUI-Unterklassen machen zu können. Der Auftrag dazu für die Schüler und Schülerinnen: Erstelle eine Skizze, wie die (quadratische) Grafikoberfläche für dein Modul aussehen soll, welche Knöpfe oder Felder du darin gerne hättest, und welche Methoden dir das Objekt zur Verfügung stellen soll, damit du die Oberfläche auf die gewünschte Weise verändern kannst.

(Hilfsmethoden, die die Klasse Modul zur Verfügung stellt: Abspielen von mp3-Dateien, Erzeugen von Tönen, Verzögertes Ausführen einer Methode, Countdown.)

– In den Sommerferien komme ich hoffentlich endlich mal dazu, meine ganzen Programmierprojekte für die 10. Jahrgangsstufe ordentlich bei github oder so einzustellen und in einem Mebiskurs zu präsentieren.