Flood Fill

Floodfill bzw. Flutfüllung ist ein Begriff aus der Computergrafik . Es ist ein einakter Algorithmus , Über Flächen zusammenhängender Pixel .

Ausgehend von einem Pixel innerhalb der Fläche wurden getestet und getestet von Nachbarpixel darauf, die Nachbarpixel auch alte Farbe enthalten. Jedes gefundene Pixel mit der alten Farbe wird dabei durch die neue Farbe ersetzt.

Zwei Varianten des Algorithmus sind gangbare:

4-connected oder 4-neighbour

Sie wurden zu Juden, die zu viert waren. Bild unten, links, oben und rechts aus der Perspektive (Koordinatenursprung ist links oben im Eck).

fill4 ( x , y , alteFarbe , neueFarbe ) {
 if ( getPixel ( x , y ) == alteFarbe ) {
 setPixel ( x , y , neueFarbe );
 fill4 ( x , y + 1 , alteFarbe , neueFarbe ); // unten
 fill4 ( x , y - 1 , alteFarbe , neueFarbe ); // oben
 fill4 ( x - 1 , y , alteFarbe , neueFarbe ); // Links
 fill4 ( x + 1 , y , alteFarbe , neueFarbe ); // rechts
 }
 zurückkehren ;
}

8-connected oder 8-neighbour

Sie wurden zu Juwelen, die zu acht waren: Pixel oben, unten, links, rechts, oben-links, oben-rechts, unten-links und unten-rechts aus dem Objekt (Koordinatenursprung ist links oben im Eck).

fill8 ( x , y , alteFarbe , neueFarbe ) {
 if ( getPixel ( x , y ) == alteFarbe ) {
 setPixel ( x , y , neueFarbe );
 fill8 ( x , y + 1 , alteFarbe , neueFarbe ); // unten
 fill8 ( x , y - 1 , alteFarbe , neueFarbe ); // oben
 fill8 ( x + 1 , y , alteFarbe , neueFarbe ); // right
 fill8 ( x - 1 , y , alteFarbe , neueFarbe ); // Links
 fill8 ( x + 1 , y + 1 , alteFarbe , neueFarbe ); // unten-rechts
 fill8 ( x + 1 , y - 1, alteFarbe , neueFarbe ); // ob-right
 fill8 ( x - 1 , y + 1 , alteFarbe , neueFarbe ); // unten-links
 fill8 ( x - 1 , y - 1 , alteFarbe , neueFarbe ); // oben-links
 }
 zurückkehren ;
}

Bei gleichen Ausgangsbedingungen fasst die 8- fach -Variante wie ein 4- fach -Variante, wenn „durch feine Ritzen schreit“. Dies ist häufig nicht gewünscht.

Das Hotel liegt in der Nähe der Nicht-trivialen Anwendungen. Dort ist Algorithmus hoch-rekursiv. Daher ist ein solches Risiko, dass der Algorithmus zu einem Stack-Überlauf führt. Zufällig näherten sich die gestaffelten Stack-Operationen, die den Vergleich zu den tatsächlichen Operationen des Algorithmus relativ zur Zeit rekrutierten.

Nicht getestet wurden unerreichte Pixel, die zuvor auf der Neuen Farbe gesetzt wurden. Jede Rekursion tripple mindestens auf einem Solo Pixel, jenes Pixel, welches in Deutschland gemacht wurde.

Iterative Flutfüllung

Mit Hilfe Eines Stapelspeicher oder Ein ähnliches Datum Struktur ist also Eine iterative Implementierung Möglich. Dabei wurden die Nachbarpixel- Koordinaten buchstabiert und fortwährend abgearbeitet. Die reihenfolge, sterben in der Koordinaten aus der seit Struktur ausgelesen Werden, spielt dabei keine Rolle. Durch die hohen Risiken eines Stack-Uberlaufs bei der rekursiven Flutfüllung ist die iterative Version in der Regel die Bessere Wahl zur Implementierung des Verfahrens.

fill4 ( x , y , alteFarbe , neueFarbe ) {
 Stapel . drücke ( x , y );
 while ( stack . isNotEmpty ) {
 ( x , y ) = Stapel . Pop ;
 if ( getPixel ( x , y ) == alteFarbe ) {
 setPixel ( x , y , neueFarbe));
 stapeln . drücke ( x , y + 1 );
 stapeln . drücken ( x , y - 1 );
 stapeln . drücke ( x + 1 , y );
 stapeln . drücke ( x - 1 , y );
 }
 }
 zurückkehren ;
}

Dieses Beispiel entspricht dem rekursiven Algorithmus mit vier Nachbarn. Derjenige, der meine acht Nachbarn implementiert hat, wird entsprechend analog.

Teiliterative Flutfüllung (Span Floodfill)

Bei teiliterativer Flutfüllung wird der Algorithmus aus einem iterativen Teil, der immer verfügbar ist, so bald wie möglich in naher Zukunft vergeben. Wenn der iterative Teil keine Pixel mehr zum Einfärben findet, wird der rekursive Teil gestartet, der nun deutlich in die Rekursion fällt. Somit ist ein Stack-Uberlauf weniger wahrscheinlich.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.