Beispiel Angabe

Kürzel:asciishop-A05-PP
Name:AsciiShop, Runde#5
Kette:Asciishop PP
Kategorie:Bildverarbeitung

Mitgelieferte Datei(en):
Abzugebende Datei(en): AsciiImage.java, AsciiShop.java
Optional abzugebende Datei(en):
Ausführbar: AsciiShop

Die Klasse AsciiShop ist zu erstellen und soll eine ausführbare Klasse sein und muss daher die public static void main(String[] args) Methode beinhalten. Ihr Programm wird automatisch auf Korrektheit überprüft. Die Überprüfung erfolgt durch die Ausführung der als ausführbar bezeichneten Klasse (AsciiShop).

Kurzbeschreibung:

Das Programm erstellt im ersten Schritt ein leeres Bild, auf dem anschließend unterschiedliche Operationen ausgeführt werden können. Neben dem Laden von Bilddaten und dem Transponieren, ist auch das Zeichnen von Linien, sowie das Ersetzen von Zeichen und das Löschen des gesamten Bildinhaltes möglich. Mit Hilfe eines eigenen Befehls lässt sich das aktuelle Bild jederzeit ausgeben.

Lernziele:

Aufgabenstellung Klassen und Methoden Ein- und Ausgabedaten Bewertung und Kriterien
Hinweise FAQ Fehlerbehandlung Testen

 

Aufgabenstellung:

Um die Flexibilität der Klasse AsciiImage zu erhöhen, wird die Speicherung der Bilddaten in dieser Runde auf ein zweidimensionales Array umgestellt. Pixelweise Manipulationen sind so leichter durchzuführen, Operationen auf dem Bild können einfacher implementiert werden. Es werden drei neue Operationen auf einem Bild implementiert und transpose und fill aus Runde 4 übernommen.

Erzeugen des Bildes

Im Gegensatz zu den bisherigen Runden soll ab dieser Runde der Umgang mit ASCII-Bildern flexibler gestaltet werden. Als neuer Befehl kommt create hinzu, dessen Parameter die Breite und Höhe eines neu zu erzeugenden Bildes spezifizieren. Dieser muss der erste eingegebene Befehl sein. Sind Breite oder Höhe kleiner oder gleich null, so soll "INPUT MISMATCH" ausgegeben werden.

Das leere Bild kann mit Daten gefüllt werden. Dazu stehen verschiedene Befehle zur Verfügung, darunter der Befehl load, der den bisherigen Befehl read ersetzt. Der Befehl load (und damit das Einlesen von Bildern von der Standardeingabe) ist von nun an für ein gültiges Bild nicht notwendig.

Befehle und Operationen am Bild

Die folgenden Befehle sind zulässig, neue Befehle sind farblich hervorgehoben, nicht mehr geforderte durchgestrichen:

Die genannten Befehle clear, line, replace, transpose und fill haben entsprechende Methoden in der Klasse AsciiImage. Alle hier aufgeführten Befehle können in beliebiger Reihenfolge auftreten. So kann zum Beispiel nach create erst print und danach load folgen.

Linien zeichnen

Mit Hilfe des DDA-Algorithmus (vgl. Digital_Differential_Analyzer_(graphics_algorithm)) soll eine Linie vom Anfangspunkt (x0,y0) bis zum Endpunkt (x1,y1) gezeichnet werden, wobei beide Punkte auf der Linie liegen sollen. Folgende Informationen können aus den Punkten gewonnen werden: Δx=x1-x0 ist der Abstand der Punkte entlang der x-Achse, Δy=y1-y0 ist der Abstand der Punkte entlang der y-Achse. Für das Zeichnen von Linien müssen nun mehrere Fälle unterschieden werden. Diese lassen sich jedoch alle auf den folgenden Hauptfall zurückführen:

1) |Δy|≤|Δx|, Δx≥0

Dies bedeutet, dass die Linie eine Steigung zwischen -45 Grad und +45 Grad aufweist und der Endpunkt einen größeren x-Wert hat als der Startpunkt. Um eine Linie gemäß diesem Fall zu zeichnen, empfiehlt sich folgende Überlegung:
Bewegt man sich auf der x-Achse Δx Einheiten nach rechts, so bewegt sich die Linie offensichtlich Δy Einheiten auf der y-Achse. Daraus folgt, dass einer Bewegung um eine Einheit auf der x-Achse einer Bewegung um Δy/Δx Einheiten entlang der y-Achse entspricht. Die Bewegung auf der y-Achse ist aufgrund der Forderung, dass |Δy|≤|Δx|, betragsmäßig kleiner als 1.
Soll nun die Linie gezeichnet werden, beginnen wir bei x=x0, y=y0. Den x-Wert erhöhen wir, wie in der vorhergehenden Überlegung beschrieben, immer um eine Einheit, den y-Wert um Δy/Δx. In jedem dieser Schritte ergibt sich der zu zeichnende Pixel aus (x,y), wobei y gerundet werden muss.


DDA, 1. Schritt Zuerst wird Δy und Δx berechnet: Δy=y1-y0=3-1=2 und Δx=x1-x0=5-1=4
Daraus berechnet sich die Steigung der Geraden Δy/Δx=2/4=0.5
DDA, 2. Schritt x läuft nun von x0 bis x1, y wird mit y0 initialisiert
Der Punkt (x,y)=(x0,y0)=(1,1) wird gezeichnet
x wird um 1 erhöht und ist nun 2
y wird um Δy/Δx=0.5 erhöht und ist nun 1.5
DDA, 3. Schritt Der Punkt (x,y)=(2,1.5) soll gezeichnet werden, dafür muss die y-Koordinate gerundet werden und somit ergibt sich (2,2) als zu zeichnender Punkt.
x=x+1=3
y=y+0.5=2.0
DDA, 4. Schritt Der Punkt (x,y)=(3,2.0) soll gezeichnet werden, das Runden der y-Koordinate ergibt hier den Punkt (3,2).
x=x+1=4
y=y+0.5=2.5
DDA, 5. Schritt Der Punkt (x,y)=(4,2.5) soll gezeichnet werden, es muss wiederum auf ganzzahlige Indizes gerundet werden, wodurch sich der zu zeichnende Punkt (4,3) ergibt.
x=x+1=5
y=y+0.5=3.0
DDA, 6. Schritt Der Punkt (x,y)=(5,3.0) soll gezeichnet werden, das Runden der y-Koordinate ergibt den Punkt (5,3).
x hat nun x1 erreicht und somit terminiert der Algorithmus.

2) |Δy|≤|Δx|, Δx<0

Sehr ähnlich sieht die Lösung aus, wenn der Endpunkt einen kleineren x-Wert als der Startpunkt hat (sprich links davon liegt). In diesem Fall erfolgt die Bewegung entlang der x-Achse immer um -1 Einheit und entlang der y-Achse um -Δy/Δx Einheiten. Ansonsten erfolgt die Umsetzung analog. Alternativ kann dieser Fall auch durch Vertauschen des Anfangs- und des Endpunkts behandelt werden.

3) |Δy|>|Δx|, Δy≥0

In diesem Fall ist nun die Veränderung entlang der y-Achse betragsmäßig größer, als die entlang der x-Achse. Anschaulich gesprochen bedeutet dies, dass einer Bewegung auf der y-Achse um eine Einheit eine Bewegung entlang der x-Achse um Δx/Δy Einheiten entspricht. Analog zum ersten beschriebenen Fall, wird schrittweise der y-Wert um eine Einheit und der x-Wert um Δx/Δy erhöht. Dies kann durch Vertauschen der x- und y-Koordinaten auf den 1. Fall zurückgeführt werden, wobei diese Vertauschung beim Zeichnen rückgängig gemacht werden muss.

4) |Δy|>|Δx|, Δy<0

Dieser Fall entsprich weitgehend Fall 3, jedoch hat der Endpunkt einen kleineren y-Wert als der Startpunkt. Dies lässt sich wiederum mittels Bewegungen um -1 Einheit in y-Richtung und -Δx/Δy Einheiten in x-Richtung lösen, alternativ durch Vertauschen von Anfangs- und Endpunkt, sowie Vertauschung der x- und y-Koordinaten.

Implementierung

Bei dieser Implementierung werden bei Bedarf Anfangs- und Endpunkt bzw. die x- und y-Achse vertauscht.

  1. Δx und Δy berechnen
  2. Feststellen ob die Achsen invertiert sind (sprich |Δy|>|Δx|)
  3. Falls die Achsen vertauscht sind, x0 mit y0, x1 mit y1 und Δx mit Δy vertauschen
  4. Überprüfen ob x1≥x0, ansonsten Anfangs und Endpunkt vertauschen
  5. x mit x0 initialisieren und in einer Schleife bis x1 in 1-Pixel-Schritten iterieren, y mit y0 initialisieren
    1. Den Punkt an der Stelle (x,y) oder, wenn die Achsen in Schritt 3 vertauscht wurden, an der Stelle (y,x) zeichnen
    2. x um 1 erhöhen
    3. y um Δy/Δx erhöhen

Übungsmöglichkeiten

Sie können zu Übungszwecken in AsciiImage auch die Methoden getUniqueChars und flipV aus Runde 4 entsprechend der Spezifikation implementieren und diesen Methoden die entsprechenden Befehle uniqueChars und flip-v zuordnen. Dies wird jedoch nicht getestet.

 

Klassen und Methoden:

Die folgende Aufzählung umfasst geforderte Methoden, neue Methoden sind farblich hervorgehoben. Sie können nach Bedarf Hilfsmethoden und Methoden für freiwillige Aufgaben (Bonusaufgaben, Übungsaufgaben) hinzufügen. Achten Sie auf die korrekte Datenkapselung. Insbesondere sollen Sie sinnvolle Zugriffsmodifikatoren für Variablen (und Methoden) verwenden.

AsciiShop
Diese Klasse ist ausführbar und beinhaltet daher die main-Methode. Sie verarbeitet die Eingaben, erzeugt das AsciiImage und gibt das Ergebnis aus. Methoden dieser Klasse lesen direkt von System.in ein und geben direkt auf System.out aus.
public static void main(String[] args)
liest die Daten und Befehle ein und gibt das Ergebnis aus.
AsciiImage
Diese Klasse repräsentiert ein ASCII-Bild, es speichert die Zeichen des Bildes und bietet entsprechende Methoden zur Modifikation und zur Abfrage von Eigenschaften, wie beispielsweise Höhe und Breite. Methoden dieser Klasse lesen weder direkt von System.in ein, noch geben sie direkt auf System.out aus.
public AsciiImage(int width, int height)
erzeugt ein ASCII-Bild der spezifizierten Größe. Anfangs sind alle Pixel auf den Wert ‘.’ gesetzt. Sie dürfen an dieser Stelle davon ausgehen, dass Breite und Höhe beide größer 0 sind. Überprüfen Sie diese Bedingung an geeigneter Stelle in der Klasse AsciiShop.
public void clear()
setzt alle Pixel des Bildes auf das Zeichen ‘.’.
public void drawLine(int x0, int y0, int x1, int y1, char c)
zeichnet eine Linie zwischen den Koordinaten (x0,y0) und (x1,y1). Anfangs- und Endpunkt sind dabei inkludiert. c spezifiziert das zu verwendende Zeichen. Sie können davon ausgehen, dass nur gültige Koordinaten übergeben werden.
public int getHeight()
gibt die Höhe des Bildes (die Anzahl der Zeilen) zurück.
public char getPixel(int x, int y)
gibt das an den übergebenen Koordinaten/Indizes gespeicherte Zeichen zurück. Sie dürfen an dieser Stelle davon ausgehen, dass die x und y gültige Koordinaten sind.
public int getWidth()
gibt die Breite des Bildes (die Länge der Zeilen) zurück.
public void replace(char oldChar, char newChar)
ersetzt alle Vorkommen eines bestimmten Zeichens oldChar im Bild durch ein anderes Zeichen newChar.
public void setPixel(int x, int y, char c)
speichert an den übergebenen Koordinaten/Indizes das übergebene Zeichen. Sie dürfen an dieser Stelle davon ausgehen, dass x und y gültige Koordinaten sind.
public String toString()
gibt eine lesbare Darstellung des ASCII-Bildes zurück. Die einzelnen Zeilen sollen dabei durch Zeilenumbrüche ‘\n’ getrennt werden.
public int getUniqueChars()
public void flipV()
public void transpose()
vertauscht Zeilen und Spalten des Bildes, sprich aus der ersten Zeile im Bild wird die erste Spalte usw. Dabei ändern sich Höhe und Breite des Bildes (vgl. Matrix_(Mathematik)). Je nach Implementierung muss diese Methode sicherstellen, dass abhängige Eigenschaften des Bildes (Höhe, Breite) aktualisiert werden. Nutzen Sie für diese Methode wenn möglich ihren Code aus Runde 4 und passen Sie ihn entsprechend an.
public void fill(int x, int y, char c)
Ersetzt das Zeichen an der Position (x,y) mit dem Zeichen c und ruft sich ggfs. selbst rekursiv auf (mit neuen Werten von (x,y) die den Nachbarpositionen entsprechen). Die Methode implementiert den rekursiven Floodfill Algorithmus (siehe Runde 3). Nutzen Sie für diese Methode wenn möglich ihren Code aus Runde 4 und passen Sie ihn entsprechend an.

 

Hinweise:

Beachten Sie die allgemeinen Hinweise zur Installation und zur Ein-/Ausgabe, sowie zur Abgabe und zur Beurteilung in den FAQ.

Einlesen von Bilddaten

Im Gegensatz zu früheren Runden erfolgt das Einlesen nun mit dem Befehl load. Dessen Parameter gibt eine Zeichenkette an, die das Ende der Daten markiert. Diese Endmarkierung muss in einer eigenen Zeile stehen. Lesen Sie die Bilddaten solange zeilenweise ein, bis sie zu dieser End-Zeichenkette gelangen. Überprüfen Sie beim Einlesen auch, ob die Breite und Höhe der eingelesenen Bilddaten mit dem mittels create erzeugten Bild übereinstimmen.

Speicherung

Zur Speicherung der Bilddaten in AsciiImage soll ein zweidimensionales char-Array verwendet werden. Bei einem neu erzeugten Bild sollen alle Pixel auf das Zeichen ‘.’ gesetzt werden.

Linien zeichnen

Verwenden Sie bei Ihrer Implementierung des DDA für alle kommabehafteten Zahlen Variablen vom Typ double, um die Rechenfehler zu minimieren.

Wenn Sie Fragen zur Implementierung oder auch zu Java haben, können Sie das Informatik-Forum nutzen. Im Rahmen der wöchentlichen Laborien stehen Tutoren für Fragen zur Verfügung.
Informatik-Forum Laborien

 

Eingabedaten:

Der erste Befehl muss create, gefolgt von Breite und Höhe des Bildes sein. Danach können in beliebiger Reihenfolge beliebige viele der oben definierten Befehle folgen. Beachten Sie jedoch, dass der create Befehl nur einmal (nämlich als erster Befehl) auftreten darf. Sie dürfen davon ausgehen, dass die mittels load eingelesenen Bilddaten keine Leerzeichen enthalten. Sie können weiters davon ausgehen, dass die gesamte Eingabe nicht leer ist.

Ausgabedaten:

Bei jedem Aufruf von print soll das Bild korrekt formatiert und von einer Leerzeile gefolgt ausgegeben werden. Im Gegensatz zu früheren Runden, erfolgt die Ausgabe nicht mehr automatisch am Ende des Programms, sondern nur bei Eingabe dieses Befehls.

Fehlerbehandlung:

Geben Sie "INPUT MISMATCH" aus und brechen Sie die weitere Verarbeitung ab, falls einer der folgenden Fehler auftritt:

Geben Sie "UNKNOWN COMMAND" aus und brechen Sie die weitere Verarbeitung ab, falls einer der folgenden Fehler auftritt:

Geben Sie "OPERATION FAILED" aus und brechen Sie die weitere Verarbeitung ab, falls der folgende Fehler auftritt:

Testen:


In
create 30 27
load end
============,.V+.;============
===========;.X##..;===========
===========..####..===========
==========,.##M###.:==========
=========;.R##WW##=.;=========
=========..##MWMW##,.=========
========:.I##WWMWW#W.,========
=======;.:##WWWWWW##I.;=======
=======:.W########M##..=======
=======.:############V.;======
=======.####...,.,M###,.======
======,.###:..+++;,B..#.;=====
=====;.#;.#i+YXVVY:#V.#..:====
====:..#..##.RYYIt##...#=.,===
==;..+#;...#######W....##W..:=
:..t###......iVV=....,.+#iM#..
.B#i,#..,,..........,,..#,..#I
V#...#..,,,,,.,,,,:,,,..R#..V#
;#+.i#..,,,,,,,,,.,,,,,.iX.X#,
.i#=MV..,,,,.,,,,,,.,,,..###..
,.t##..,,,,,,,,,,,,,,:,..V##.;
..M#M..,,,,.,.,,,,,,,:,,.=##..
i###M..,...........,,:,,..###.
.####........=II;.....,,.;##R.
,...#....X####MW###B.....Wi..:
==;,##,###;........##i...#;,==
===,.IVi..,;======:..B#B#t.;==
end
print
clear
print
Out
============,.V+.;============
===========;.X##..;===========
===========..####..===========
==========,.##M###.:==========
=========;.R##WW##=.;=========
=========..##MWMW##,.=========
========:.I##WWMWW#W.,========
=======;.:##WWWWWW##I.;=======
=======:.W########M##..=======
=======.:############V.;======
=======.####...,.,M###,.======
======,.###:..+++;,B..#.;=====
=====;.#;.#i+YXVVY:#V.#..:====
====:..#..##.RYYIt##...#=.,===
==;..+#;...#######W....##W..:=
:..t###......iVV=....,.+#iM#..
.B#i,#..,,..........,,..#,..#I
V#...#..,,,,,.,,,,:,,,..R#..V#
;#+.i#..,,,,,,,,,.,,,,,.iX.X#,
.i#=MV..,,,,.,,,,,,.,,,..###..
,.t##..,,,,,,,,,,,,,,:,..V##.;
..M#M..,,,,.,.,,,,,,,:,,.=##..
i###M..,...........,,:,,..###.
.####........=II;.....,,.;##R.
,...#....X####MW###B.....Wi..:
==;,##,###;........##i...#;,==
===,.IVi..,;======:..B#B#t.;==

..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
..............................
Beschreibung Ein Bild wird eingelesen und ausgegeben, danach wird das Bild gelöscht und das nunmehr leere Bild ausgegeben.


In
create 20 10
line 1 1 18 4 x
line 1 3 18 6 o
line 1 8 18 8 #
print
Out
....................
.xxx................
....xxxxxx..........
.ooo......xxxxxx....
....oooooo......xxx.
..........oooooo....
................ooo.
....................
.##################.
....................
Beschreibung Drei einfache Linien werden gezeichnet (entsprechen alle dem 1. beschriebenen Fall).


In
create 30 27
load EOI
============,.V+.;============
===========;.X##..;===========
===========..####..===========
==========,.##M###.:==========
=========;.R##WW##=.;=========
=========..##MWMW##,.=========
========:.I##WWMWW#W.,========
=======;.:##WWWWWW##I.;=======
=======:.W########M##..=======
=======.:############V.;======
=======.####...,.,M###,.======
======,.###:..+++;,B..#.;=====
=====;.#;.#i+YXVVY:#V.#..:====
====:..#..##.RYYIt##...#=.,===
==;..+#;...#######W....##W..:=
:..t###......iVV=....,.+#iM#..
.B#i,#..,,..........,,..#,..#I
V#...#..,,,,,.,,,,:,,,..R#..V#
;#+.i#..,,,,,,,,,.,,,,,.iX.X#,
.i#=MV..,,,,.,,,,,,.,,,..###..
,.t##..,,,,,,,,,,,,,,:,..V##.;
..M#M..,,,,.,.,,,,,,,:,,.=##..
i###M..,...........,,:,,..###.
.####........=II;.....,,.;##R.
,...#....X####MW###B.....Wi..:
==;,##,###;........##i...#;,==
===,.IVi..,;======:..B#B#t.;==
EOI
replace = .
print
Out
............,.V+.;............
...........;.X##..;...........
.............####.............
..........,.##M###.:..........
.........;.R##WW##..;.........
...........##MWMW##,..........
........:.I##WWMWW#W.,........
.......;.:##WWWWWW##I.;.......
.......:.W########M##.........
........:############V.;......
........####...,.,M###,.......
......,.###:..+++;,B..#.;.....
.....;.#;.#i+YXVVY:#V.#..:....
....:..#..##.RYYIt##...#..,...
..;..+#;...#######W....##W..:.
:..t###......iVV.....,.+#iM#..
.B#i,#..,,..........,,..#,..#I
V#...#..,,,,,.,,,,:,,,..R#..V#
;#+.i#..,,,,,,,,,.,,,,,.iX.X#,
.i#.MV..,,,,.,,,,,,.,,,..###..
,.t##..,,,,,,,,,,,,,,:,..V##.;
..M#M..,,,,.,.,,,,,,,:,,..##..
i###M..,...........,,:,,..###.
.####.........II;.....,,.;##R.
,...#....X####MW###B.....Wi..:
..;,##,###;........##i...#;,..
...,.IVi..,;......:..B#B#t.;..
Beschreibung Ein Bild wird eingelesen, alle = werden durch . ersetzt und das Ergebnis wird ausgegeben.


In
create 40 24
load !
........................................
...................................MM...
..............................MMMMMM,...
.........................,MMMMMMMMMM....
....................,MMMMMMMMMMMMMM.....
................MMMMMMMMMMMMMMMMMMM.....
..................MMMMMMMMMMMMMMMM......
...................MMMMMMMMMMMMMMM......
..................MMMMMMMMMMMMMMM,......
................+MMMMMMMMMMMMMMMM.......
...............MMMMMMMMMMMMMMMMM........
.............MMMMMMMMMMMMMMMMMMM........
............MMMMMMMMMMMMMM.MMMM,........
..........MMMMMMMMMMMMMM+....MM.........
........+MMMMMMMMMMMMMM.................
.......MMMMMMMMMMMMMM...................
.....MMMMMMMMMMMMMMM....................
....MMMMMMMMMMMMMM......................
..MMMMMMMMMMMMMM+.......................
..MMMMMMMMMMMMM.........................
....MMMMMMMMM...........................
.....MMMMMMM............................
.......MMM..............................
........................................
!
transpose
print
explode
Out
........................
........................
..................MM....
..................MM....
.................MMMM...
................MMMMMM..
................MMMMMM..
...............MMMMMMMM.
..............+MMMMMMMM.
..............MMMMMMMMM.
.............MMMMMMMMM..
.............MMMMMMMMM..
............MMMMMMMMM...
...........MMMMMMMMM....
...........MMMMMMMMM....
..........MMMMMMMMM.....
.....M...+MMMMMMMM+.....
.....M...MMMMMMMMM......
.....MM.MMMMMMMMM.......
.....MMMMMMMMMMMM.......
....,MMMMMMMMMMM........
....MMMMMMMMMMM.........
....MMMMMMMMMMM.........
....MMMMMMMMMM..........
....MMMMMMMMM+..........
...,MMMMMMMMM...........
...MMMMMMMMM............
...MMMMMMMMMM...........
...MMMMMMMMMM...........
...MMMMMMMMMMM..........
..MMMMMMMMMMMM..........
..MMMMMMMMMM,...........
..MMMMMMMM..............
..MMMMMM,...............
..MMMM..................
.MMM....................
.M,.....................
........................
........................
........................

UNKNOWN COMMAND
Beschreibung Ein Bild wird transponiert und ausgegeben. Danach wird der ungültige Befehl explode eingegeben.


In
create 30 27
load end
============,.V+.;============
===========;.X##..;===========
===========..####..===========
==========,.##M###.:==========
=========;.R##WW##=.;=========
=========..##MWMW##,.=========
========:.I##WWMWW#W.,========
=======;.:##WWWWWW##I.;=======
=======:.W########M##..=======
=======.:############V.;======
=======.####...,.,M###,.======
======,.###:..+++;,B..#.;=====
=====;.#;.#i+YXVVY:#V.#..:====
====:..#..##.RYYIt##...#=.,===
==;..+#;...#######W....##W..:=
:..t###......iVV=....,.+#iM#..
.B#i,#..,,..........,,..#,..#I
V#...#..,,,,,.,,,,:,,,..R#..V#
;#+.i#..,,,,,,,,,.,,,,,.iX.X#,
.i#=MV..,,,,.,,,,,,.,,,..###..
,.t##..,,,,,,,,,,,,,,:,..V##.;
..M#M..,,,,.,.,,,,,,,:,,.=##..
i###M..,...........,,:,,..###.
.####........=II;.....,,.;##R.
,...#....X####MW###B.....Wi..:
==;,##,###;........##i...#;,==
===,.IVi..,;======:..B#B#t.;==
print
Out
INPUT MISMATCH
Beschreibung Die Zeichenkette "end", die das Ende der Eingabe kennzeichnet, fehlt.


In
create 8 5
line 0 0 7 0 W
line 7 4 0 4 W
line 0 0 0 4 #
line 7 4 7 0 #
print
Out
#WWWWWW#
#......#
#......#
#......#
#WWWWWW#
Beschreibung Es werden horizontale und vertikale Linien gezeichnet.


In
create 17 21
line 8 0 16 10 X
line 16 10 8 20 X
line 8 20 0 10 X
line 0 10 8 0 X
line 8 6 14 10 o
line 14 10 8 14 o
line 8 14 2 10 o
line 2 10 8 6 o
line 8 8 10 10 #
line 10 10 8 12 #
line 8 12 6 10 #
line 6 10 8 8 #
line 8 10 8 10 +
print
Out
........X........
.......X.X.......
......X...X......
......X...X......
.....X.....X.....
....X.......X....
...X....o....X...
..X...oo.oo...X..
..X..o..#..o..X..
.X.oo..#.#..oo.X.
X.o...#.+.#...o.X
.X.oo..#.#..oo.X.
..X..o..#..o..X..
..X...oo.oo...X..
...X....o....X...
....X.......X....
.....X.....X.....
......X...X......
......X...X......
.......X.X.......
........X........
Beschreibung Linien unterschiedlichster Steigung werden gezeichnet (enthält Linien zu allen beschriebenen Fällen).


In
create 17 21
line 8 0 16 10 X
line 16 10 8 20 X
line 8 20 0 10 X
line 0 10 8 0 X
fill 8 1 X
print
line 8 8 10 10 .
line 10 10 8 12 .
line 8 12 6 10 .
line 6 10 8 8 .
fill 8 9 .
print
Out
........X........
.......XXX.......
......XXXXX......
......XXXXX......
.....XXXXXXX.....
....XXXXXXXXX....
...XXXXXXXXXXX...
..XXXXXXXXXXXXX..
..XXXXXXXXXXXXX..
.XXXXXXXXXXXXXXX.
XXXXXXXXXXXXXXXXX
.XXXXXXXXXXXXXXX.
..XXXXXXXXXXXXX..
..XXXXXXXXXXXXX..
...XXXXXXXXXXX...
....XXXXXXXXX....
.....XXXXXXX.....
......XXXXX......
......XXXXX......
.......XXX.......
........X........

........X........
.......XXX.......
......XXXXX......
......XXXXX......
.....XXXXXXX.....
....XXXXXXXXX....
...XXXXXXXXXXX...
..XXXXXXXXXXXXX..
..XXXXXX.XXXXXX..
.XXXXXX...XXXXXX.
XXXXXX.....XXXXXX
.XXXXXX...XXXXXX.
..XXXXXX.XXXXXX..
..XXXXXXXXXXXXX..
...XXXXXXXXXXX...
....XXXXXXXXX....
.....XXXXXXX.....
......XXXXX......
......XXXXX......
.......XXX.......
........X........
Beschreibung Ein 17x21 Pixel großes Bild wird erzeugt und darin ein Rautenmuster mit 4 Linien gezeichnet. Die Rauten fläche wird eingefärbt und das Bild ausgegeben. Danach wird ein weiteres kleineres Rautenmuster gezeichnet, eingefärbt und das Bild erneut ausgegeben.


Bemerkung: Diese Beispiele dienen nur zur Verdeutlichung der Spezifikation und müssen nicht korrekt formatiert sein. Die korrekte Formatierung entnehmen Sie bitte dem mitgelieferten Outputfile. Zum Testen Ihrer Lösung können Sie aus den mitgelieferten Eingabedaten wie folgt eine Ausgabedatei erzeugen:
java AsciiShop < asciishop-A05-PP.i1 > asciishop-A05-PP.out1

Das erzeugte File asciishop-A05-PP.out1 können Sie dann mit dem mitgelieferten Outputfile asciishop-A05-PP.o1 vergleichen.