# Problem mit einem rekursivem FloodFill Algorithmus



## Soltan (11. Jan 2018)

Folgender Code

```
private static void floodFill(int[][] imgArr, int sx, int sy){
    
      
if(sx<0) return;
if(sx>imgArr[sy].length-1) return;
if(sy<0) return;
if(sy>imgArr.length-1) return;
     
        imgArr[sy][sx]=1;

        floodFill(imgArr, sx+1, sy);
        floodFill(imgArr, sx-1, sy);
        floodFill(imgArr, sx, sy+1);
        floodFill(imgArr, sx, sy-1);
    }
```


Ich verstehe nicht warum bei diesem Code nur eine einzige Zeile mit 1 gefüllt wird.  Ich begreife es einfach nicht... kann mir wer helfen ?


----------



## truesoul (11. Jan 2018)

Hallo.

Du wahrscheinlich läufst in ein Stackoverflow Fehler und nach

```
floodFill(imgArr, sx + 1, sy);
floodFill(imgArr, sx - 1, sy);
```

Werden die

```
floodFill(imgArr, sx, sy + 1);
floodFill(imgArr, sx, sy - 1);
```
nie erreicht.

Zudem stimmen deine Abbruchbedingungen nicht.

sx kann auch aus dem Bereich von der länge deines Arrays laufen.

Schau dir nochmal deine Bedingungen an:


```
if(sx<0) return;
if(sx>imgArr[sy].length-1) return;
if(sy<0) return;
if(sy>imgArr.length-1) return;
```

Grüße


----------



## Soltan (11. Jan 2018)

Dh die 4 rekursiven aufrufe sind falsch angeordnet ? Oder auch inhaltlich nicht so zu verwenden ?
Das mit der Abbruchbedingung stimmt jo, das leuchtet mir ein. Den rekursiven Aufruf mit dem hadere ich noch...


----------



## Meniskusschaden (11. Jan 2018)

Mach' doch mal einen Schreibtischtest. Dann erkennst du das Problem ziemlich schnell. Ich würde dafür aber ein kleines Array nehmen - vielleicht 3x3. Sonst wird's zu aufwändig.


----------



## Soltan (11. Jan 2018)

Jeder einzelne Beitrag den ich im Netz darüber finde inklusive youtube videos implementiert das genau so... checks nicht.
https://www.geeksforgeeks.org/flood-fill-algorithm-implement-fill-paint/
https://www.codeproject.com/Articles/6017/QuickFill-An-efficient-flood-fill-algorithm
etc etc etc


----------



## truesoul (11. Jan 2018)

Soltan hat gesagt.:


> Jeder einzelne Beitrag den ich im Netz darüber finde inklusive youtube videos implementiert das genau so... checks nicht.
> https://www.geeksforgeeks.org/flood-fill-algorithm-implement-fill-paint/
> https://www.codeproject.com/Articles/6017/QuickFill-An-efficient-flood-fill-algorithm
> etc etc etc



Na ja. Deins unterscheidet sich schon von allen Beispielen im Netz. Siehe Link von dir.


----------



## Soltan (11. Jan 2018)

Warum soll sx aus der Länge des arrays laufen können ?


----------



## Soltan (11. Jan 2018)

```
if(sx<0) return;
        if(sx>imgArr[sy].length-1) return;
        if(sy<0) return;
        if(sy>imgArr.length-1) return;

       
        floodFill(imgArr, sx-1, sy, gVal, gThresh);
        floodFill(imgArr, sx+1, sy, gVal, gThresh);
        floodFill(imgArr, sx, sy-1, gVal, gThresh);
        floodFill(imgArr, sx, sy+1, gVal, gThresh);
```

Was zum Teufel ist nicht korrekt....


----------



## Soltan (11. Jan 2018)

```
// Base cases
    if (x < 0 || x >= M || y < 0 || y >= N)
        return;

floodFillUtil(screen, x+1, y, prevC, newC);
    floodFillUtil(screen, x-1, y, prevC, newC);
    floodFillUtil(screen, x, y+1, prevC, newC);
    floodFillUtil(screen, x, y-1, prevC, newC);
```

code aus nem tutorial....


----------



## Meniskusschaden (11. Jan 2018)

Soltan hat gesagt.:


> ```
> // Base cases
> if (x < 0 || x >= M || y < 0 || y >= N)
> return;
> ...


Na ja, wenn das der gesamte Code ist, wird's da wohl auch nicht funktionieren.


Soltan hat gesagt.:


> Was zum Teufel ist nicht korrekt....


Warum gehst du der Sache nicht einfach selbst auf den Grund? So lange Tutorials zu durchwühlen, bis du es irgendwann mal richtig abgeschrieben hast, scheint ja keine Zeit zu sparen und vom Lerneffekt bringt's ohnehin nichts.


----------



## Soltan (11. Jan 2018)

Dude.... ich bin alleine deswegen hier in diesem Forum weil ich mir schon stundenlang den Kopf zerbreche und einfach nicht dahinter komme..... ich habs schon aufgezeichnet alles..... Selbst wenn ich garkeine Abbruchbedinung angebe bekomme ich dasselbe Ergebniss weil es eben nur in dieser einen Zeile hin und her läuft... dachte mir mir kann jemand HELFEN. Wie soll ich ausserdem dahinter kommen ausser zu recherchieren wenn ich selbst nicht draufkomme.....


----------



## Meniskusschaden (11. Jan 2018)

Hast du den Schreibtischtest schon gemacht? Dann müsste dir bei den rekursiven Aufrufen eigentlich etwas auffallen. Hier mal die ersten Aufrufe für ein 3x3-Array:

```
floodFill(imgArr, 0, sy);
    floodFill(imgArr, 1, sy);
        floodFill(imgArr, 2, sy);
            floodFill(imgArr, 3, sy);
            floodFill(imgArr, 1, sy);
                floodFill(imgArr, 2, sy);
```


----------



## Soltan (11. Jan 2018)

y verändert sich nicht ?


----------



## Meniskusschaden (11. Jan 2018)

Nein, das ist nicht das Wesentliche. Am besten setzt du den Test noch etwas weiter fort. Die korrekten Einrückungen für die Aufruftiefe sind dabei wichtig.


----------



## Soltan (11. Jan 2018)

Bei 3 bricht es ab und geht quasi auf 1 zurück..... dann sollte des - kommen.... dann bin ich wieder in diesem Szenario wo es einfach in einer Zeile endlos hin und her springt.... ich bin schon derartig frustriert


----------



## Meniskusschaden (11. Jan 2018)

Warum geht es bei drei nicht weiter und warum geht es danach mit 1 weiter?


----------



## Soltan (11. Jan 2018)

Ich habe nicht die geringste Ahnung. Wenn danach der Aufruf mit x-1 kommt sollte es eigentlich mit 2 aufgerufen werden und danach wieder mit x+1


----------



## Meniskusschaden (11. Jan 2018)

Soltan hat gesagt.:


> Wenn danach der Aufruf mit x-1 kommt sollte es eigentlich mit 2 aufgerufen werden


Nein. Wenn x=3 ist, wird die Methode mit return verlassen und dadurch eine Aufrufebene zurück gesprungen. Dort hat x den Wert 2, also ergibt x-1 den Wert 1.


----------



## Soltan (11. Jan 2018)

Ja ok das versteh ich . Tja wir sind dann wieder bei diesem ewigem Szenario wo halt auf der x Achse bis in alle Ewigkeiten hin und her gezeichnet wird.... Im Grunde kann dann jegliche Geschichte die x+1 und x-1 aufeinander folgend hat ( wie in 90% aller Erklärungen) eigentlich nie funktionieren...


----------



## Blender3D (11. Jan 2018)

Soltan hat gesagt.:


> // Base cases
> if (x < 0 || x >= M || y < 0 || y >= N)
> return;
> 
> ...



Code kann niemals stimmen Du rufst die Funktion viel zu oft auf. Der Sinn dieser Rekursion kann immer nur darin bestehen, dass man z.B. bei einem 3x3 Array auch genau 9 Aufrufe der Funktion hat. Z.B.

```
public static void floodFill(int[][] imgArr, int sx, int sy) {
        if (sy > imgArr.length - 1)
            return;
        imgArr[sy][sx] = 1;
        if (sx < imgArr[0].length - 1)
            floodFill(imgArr, sx + 1, sy);
        else
            floodFill(imgArr, 0, sy + 1);
    }
```
 Pro  imgArr[sy][sx] = 1; folgt ein floodFill


----------



## Soltan (11. Jan 2018)

k ich geb auf. Muss mir nen Profi checken der mir das mal wirklich erklären kann. Keine Chance das bis morgen früh jemals zu implementieren. Danke für eure Mühe


----------



## Meniskusschaden (11. Jan 2018)

Soltan hat gesagt.:


> k ich geb auf.


Welches Problem ist denn noch übrig?

Die ursprüngliche Frage:


Soltan hat gesagt.:


> Ich verstehe nicht warum bei diesem Code nur eine einzige Zeile mit 1 gefüllt wird.


ist doch schon geklärt.

Dass diese:


Soltan hat gesagt.:


> ( wie in 90% aller Erklärungen)


Erklärungen für dich nicht funktionieren, liegt daran, dass sie sich mit einem anderen Problem beschäftigen.

Und dazu:


Soltan hat gesagt.:


> Keine Chance das bis morgen früh jemals zu implementieren.


hat @Blender3D doch schon etwas Konkretes geschrieben.


----------



## Soltan (12. Jan 2018)

Ich schaffe es einfach nicht einen funktionierenden Code zu implementieren... Blenders befüllt nur die obere Seite des Arrays. Spiel mich schon seit ner Stunde einen Weg zu finden auch die untere zu befüllen.... Ich stoße immer wieder auf das Problem dass sobald ich irgendwo ein x+1 UND ein x-1 stehen habe ich mich im Kreis bewege... dito mit y.


----------



## mrBrown (12. Jan 2018)

Blender3D hat gesagt.:


> Code kann niemals stimmen Du rufst die Funktion viel zu oft auf. Der Sinn dieser Rekursion kann immer nur darin bestehen, dass man z.B. bei einem 3x3 Array auch genau 9 Aufrufe der Funktion hat. Z.B.
> 
> ```
> public static void floodFill(int[][] imgArr, int sx, int sy) {
> ...


Das ist kein Floodfill, sondern die rekursive Umsetzung von zwei simplen verschachtelten for-Schleifen...




Soltan hat gesagt.:


> Ich schaffe es einfach nicht einen funktionierenden Code zu implementieren... Blenders befüllt nur die obere Seite des Arrays. Spiel mich schon seit ner Stunde einen Weg zu finden auch die untere zu befüllen.... Ich stoße immer wieder auf das Problem dass sobald ich irgendwo ein x+1 UND ein x-1 stehen habe ich mich im Kreis bewege... dito mit y.


Hast du mal versucht, zu verstehen, wie der Algorithmus allgemein fuktioniert, unabhängig von einer genauen Umsetzung in Code?

Im wesentlichen fehlt dir nur ein kleiner Punkt...


----------



## Soltan (12. Jan 2018)

Das Problem ist dass ich es nicht verstehe. Und jeder fragt mich nur ob ich es verstanden habe. Ich stehe einfach auf der leitung und komme seit mittlerweile ca 7 Stunden keinen einzigen Schritt weiter. Ich hätte das heute um 12 abgeben müssen.


----------



## mrBrown (12. Jan 2018)

Wenn das x-1 und danach x+1 passierte, ist er wieder an einem Feld, an dem er schon war, richtig?


----------



## Soltan (12. Jan 2018)

Genau und dann erfolgt der rekursive aufruf auf x-1 aber erneut da dies quasi der erste Aufruf ist. Es entsteht ein endloser Aufbau.


----------



## mrBrown (12. Jan 2018)

Muss der rekursive Aufuf denn noch mal erfolgen?


----------



## Soltan (12. Jan 2018)

Klar erfolgt er da er ja in der Methode enthalten ist.


----------



## mrBrown (12. Jan 2018)

Die Frage war nicht, ob der Aufruf aktuell passiert, sondern ob er, wenn er an dem Feld schon war, erneut erfolgen muss.


----------



## Soltan (12. Jan 2018)

Nein er müsste nicht passieren. Aber passiert eben in dem Moment wo ich auch mal ein x-1 drinnen habe....


----------



## mrBrown (12. Jan 2018)

Und fällt dir irgendeine Möglichleit ein, zu vermeiden, dass es erneut aufgerufen wird?


----------



## Soltan (12. Jan 2018)

Nur wenn ich einen x+ aufruf habe niemals einen x-1 aufruf zu haben und umgekehrt. Das ist aber keine Option da ich in beide Richtungen des Arrays gehen muss.


----------



## mrBrown (12. Jan 2018)

Das ist auch nicht die einzige Möglichkeit.
Du benutz selber schon eine andere, um ein rauslaufen zu verhindern.


----------



## Soltan (12. Jan 2018)

Ein rauslaufen ja ! Aber dann terminiert es an den Anfangspunkt zurück und geht nicht in die entgegen gesetzte Richtung auch .....


----------



## mrBrown (12. Jan 2018)

Häh?


Aktuell macht es jeweils dann nicht mit den rekursiven aufrufen weiter, wenn du außerhalb des Bereichs bist.
Du musst es so ergänzen, dass es auch dann nicht die Rekursiven aufrufe ausführt, wenn du an dem Punkt schon mal warst.


----------



## Soltan (12. Jan 2018)

```
if (sy > imgArr.length - 1) {
        return;
        }
        StdDraw.filledCircle(sx,sy,0.01);
        if (sx < imgArr[0].length - 1)
            floodFill(imgArr, sx + 1, sy);
        else
            floodFill(imgArr, 0, sy - 1);
```

Das hier ist einfach begrenzt und geht nur in eine Hälfte der ganzen Geschichte. Man kann das eigentlich ganz einfach zusammen fassen. Wir starten sagen wir irgendwo in der Mitte/Mitte des arrays. In dem Moment wo ich auch in die andere Richtung gehen will muss ich auch irgendwo eine Anweisung haben die besagt jetzt bitte in die ANDERE Richtung ( sprich alles was ich irgendwann ins x/y+ gehe muss ich an irgendeiner Stelle auch mal ins - gehen.) Korrekt ?


----------



## mrBrown (12. Jan 2018)

Soltan hat gesagt.:


> ```
> if (sy > imgArr.length - 1) {
> return;
> }
> ...


Die Variante hat auch wie gesagt nichts mit Floodfill zu tun.

Und ja, du brauchst die Aufrufe in beide Richtungen. Die hast du richtig und die müssen so bleiben.
Dein Problem ist die Abbruchbedingung.

(So als Tipp: einfach mal bei Wikipedia gucken)


----------



## Soltan (12. Jan 2018)

```
private static void floodFill(int[][] imgArr, int sx, int sy){
 
   
if(sx<0) return;
if(sx>imgArr[sy].length-1) return;
if(sy<0) return;
if(sy>imgArr.length-1) return;
   
        imgArr[sy][sx]=1;

        floodFill(imgArr, sx+1, sy);
        floodFill(imgArr, sx-1, sy);
        floodFill(imgArr, sx, sy+1);
        floodFill(imgArr, sx, sy-1);
    }
```

Ich weiß nichteinmal mehr über was für einen Code wir jetzt genau sprechen.
So das war meine ursprünglichste Variante. Es ist alles begrenzt. Es geht in jede Richtung. Da stoßen wir eben ganz genau auf das Problem.


----------



## mrBrown (12. Jan 2018)

Über die Variante rede ich, die war auch am nächsten an der Lösung dran...


----------



## mrBrown (12. Jan 2018)

Anderer Versuch: wann muss dem Feld (und damit auch den umliegenden) der Wert 1 zugewiesen werden?


----------



## Soltan (12. Jan 2018)

Ich könnte sagen wenn das array and der Stelle x y schon 1 ist dann returne auch. Im Falle dieses einfach arrays bsp mit 1 würde das sogar funktionieren, möchtest du auf das hinaus ?


----------



## mrBrown (12. Jan 2018)

Klingt es für dich sinnvoll? Dann probier’s aus.


----------



## Soltan (12. Jan 2018)

K meine aufgabe ist einfach ich klicke auf ein bild und soll alles einfärben was nicht den wert des klicks hat.

```
if(sx<0) return;
            if(sx>imgArr[sy].length-1) return;
            if(sy<0) return;
            if(sy>imgArr.length-1) return;

            if (imgArr[sy][sx]!=klickWert);
        {
            Draw(sx,sy,0.01);  //Das ist die Einfärbung des Pixels
            floodFill(imgArr, sx + 1, sy,klickWert);
            floodFill(imgArr, sx - 1, sy,klickWert);
            floodFill(imgArr, sx, sy + 1,klickWert);
            floodFill(imgArr, sx, sy - 1,klickWert);
        }
        }
```

Ich habe es genau so gemacht wie auf Wikipedia.(Bis auf den Rand des Bildes, das haben sie ausgelassen. Aber sollte egal sein) Ist ja eh shcon eine exakte Kopie des Codes. Was passiert ? Dasselbe wie immer.... eine Zeile wird eingefärbt. Ich war noch nie so frustriert in meinem Leben.


----------



## Soltan (12. Jan 2018)

Auch das mit dem array funktioniert nicht. Es funktioniert gar nichts von dem.


----------



## mrBrown (12. Jan 2018)

Soltan hat gesagt.:


> Ich habe es genau so gemacht wie auf Wikipedia.


Nein, du hast relevante Teile geändert.

Dein if wird ignoriert, da es mit einem Semikolon beendet wird.
Außerdem müssen der Wert, mit dem du vergleichst, und der neue Wert, den du zuweist, gleich sein.


----------



## Blender3D (12. Jan 2018)

mrBrown hat gesagt.:


> Das ist kein Floodfill, sondern die rekursive Umsetzung von zwei simplen verschachtelten for-Schleifen...


Stimmt ... 

```
public static void floodFill(int[][] a, int x, int y, int oldValue, int newValue) {
        int dimX = a.length -1;
        int dimY = a[0].length -1;
        if( x < 0 || y < 0 || x > dimX || y > dimY  )
            return;
        if (a[x][y] == oldValue) {
            a[x][y] = newValue;
            floodFill(a, x, y + 1, oldValue, newValue); // up
            floodFill(a, x, y - 1, oldValue, newValue); // down
            floodFill(a, x - 1, y, oldValue, newValue); // left
            floodFill(a, x + 1, y, oldValue, newValue); // right
        }
        return;
    }
```


```
public static  void print( int [][] a ) {
      
        for( int i = 0; i < a.length; i++ ) {
            for( int ii = 0; ii < a[0].length; ii++ )
                System.out.print( a[i][ii] +"\t" );
            System.out.println();
        }
    }
```


```
int[][] a = { { 10, 10, 10, 5 }, { 10, 10, 10, 5 }, { 10, 10, 5, 5 }, { 10, 10, 10, 5 }, { 10, 10, 10, 10 }};
      
        print(a);
        floodFill(a, 2, 1, 10, 3);
        System.out.println("********************");
        print(a);
```
Hier die Floodfillvariante:


----------



## mrBrown (12. Jan 2018)

Blender3D hat gesagt.:


>


----------



## Soltan (12. Jan 2018)

Hoppla.

```
if(sx<0) return;
            if(sx>imgArr[sy].length-1) return;
            if(sy<0) return;
            if(sy>imgArr.length-1) return;

            if (imgArr[sy][sx]==klickWert)
        {
            Draw(sx,sy,0.01);  //Das ist die Einfärbung des Pixels
            floodFill(imgArr, sx + 1, sy,klickWert);
            floodFill(imgArr, sx - 1, sy,klickWert);
            floodFill(imgArr, sx, sy + 1,klickWert);
            floodFill(imgArr, sx, sy - 1,klickWert);
        }
return;
        }
```

Obs gleich oder nicht gleich ist ändert ja aber nur ob es eben gezeichnet wird wenn es die Farbe ist oder nicht. Aber dass der Durchlauf ganz grundsätzlich nicht funktioniert.... daran ändert es auch nichts . Funktioniert aber sowieso auf egal welche Variante auch immer nicht auf die Art.


----------



## Meniskusschaden (12. Jan 2018)

Soltan hat gesagt.:


> Obs gleich oder nicht gleich ist ändert ja aber nur ob es eben gezeichnet wird wenn es die Farbe ist oder nicht.


Wenn du die Wikipedia-Lösung richtig abgeschrieben hättest, wäre es schon ein Unterschied. Da du sie falsch abgeschrieben hast, ist's natürlich egal, weil es so ohnehin nicht funktioniert.


----------



## Soltan (13. Jan 2018)

Wikipedia Code

```
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
  }
  return;
}
```

Mein Code

```
if(sx<0) return;
            if(sx>imgArr[sy].length-1) return;
            if(sy<0) return;
            if(sy>imgArr.length-1) return;


            //if (imgArr[sy][sx]==klickWert)
            //if (imgArr[sy][sx]!=klickWert)   beides funkt nicht.
             
             {
            Draw(sx,sy,0.01);
            floodFill(imgArr, sx , sy+1, klickWert);
            floodFill(imgArr, sx , sy-1, klickWert);
            floodFill(imgArr, sx-1, sy , klickWert);
            floodFill(imgArr, sx+1, sy , klickWert);
            }
            return;
        }
```

Als ob das nen Unterschied machen würde. Die Art wird niemals funktionieren.
Das funktioniert nichteinmal wenn ich nur einfach alle Pixel austauschen würde. Einfach nur ALLE. Einmal durch das ganze Array bitte.
Ist mir auch schon echt egal. Es kann oder will mir niemand hier erklären.  Werd nächste Woche auf die Uni fahren und einfach irgendwelche Profs fragen. Danke trotzdem. Cheers


----------



## mrBrown (13. Jan 2018)

Soltan hat gesagt.:


> Als ob das nen Unterschied machen würde.


Doch, macht es.


Soltan hat gesagt.:


> Die Art wird niemals funktionieren.


Doch, macht es.


Der Fehler bei dir ist immer noch das Einfärben des Pixels. Dieser muss *nach* dem Färben die Farbe *klickWert* haben, wenn du mit ungleich vergleichst.


(und ganz ehrlich: Wenn du den Code den du abschreibst änderst, ohne ihn verstanden zu haben, bringt es dir absolut nichts.)


----------



## Meniskusschaden (13. Jan 2018)

Soltan hat gesagt.:


> Es kann oder will mir niemand hier erklären.


Wenn du eine Aufgabe, die du eigentlich komplett selbstständig bearbeiten solltest, trotz fertiger Lösungsidee und zusätzlicher Hilfestellung nicht zum Laufen bekommst, hat es vielleicht auch ein wenig mit deiner eigenen Leistung zu tun. Es wurde hier einiger Aufwand investiert, um dich zu unterstützen, wenigstens die Lösungsumsetzung SELBST zu erarbeiten. Du bist aber entweder nicht wirklich daran interessiert oder im Stoff zu weit zurück. Es ist kaum möglich, noch mehr Hinweise zu geben, ohne gleich die Gesamtlösung zu präsentieren.


----------



## truesoul (13. Jan 2018)

Meniskusschaden hat gesagt.:


> ohne gleich die Gesamtlösung zu präsentieren.



Wobei die Lösungen überall zu finden sind.


----------



## Meniskusschaden (13. Jan 2018)

truesoul hat gesagt.:


> Wobei die Lösungen überall zu finden sind.


Ja, aber das Abschreiben scheint nicht trivial zu sein.


----------



## Soltan (15. Jan 2018)

Ich bedanke mich bei allen die mir geholfen haben. Bekomme es halt einfach nicht hin. Keine Ahnung. Sonst tu ich mir eigentlich nicht schwer, aber das verstehe ich einfach 0. Ich hab jetzt auch versucht alle geänderten Pixel um array umzuschreiben auf einen gewissen Wert und das auch noch als Bedingung zu nehmen.

```
if(sx<0) return;
            if(sx>imgArr[sy].length-1) return;
            if(sy<0) return;
            if(sy>imgArr.length-1) return;


            //if (imgArr[sy][sx]!=klick)
            if (imgArr[sy][sx]==klick)
             {
            imgArr[sy][sx]=klick;
            Draw(sx,sy,0.01);
            floodFill(imgArr, sx , sy+1,klick);
            floodFill(imgArr, sx , sy-1, klick);
            floodFill(imgArr, sx-1, sy , klick);
            floodFill(imgArr, sx+1, sy , klick);
            }
            return;

        }
```
Zu den Lösungen die überall zu finden sind: Tja die funktionieren eben nicht bei mir. Und ich habe keine Ahnugn warum. Dadurch dass es nur paar Zeilen sind bin ich auch am Ende zu suchen wo der Fehler liegen könnte. Letztendlich hab ich dann schon einfach wild herum probiert aus Frustration. Im Endeffekt hat nichts funktioniert und ich hab es noch immer nicht.Zeichnet immer nur einen Punkt oder manchmal eine Linie.


----------



## mrBrown (15. Jan 2018)

Soltan hat gesagt.:


> Zu den Lösungen die überall zu finden sind: Tja die funktionieren eben nicht bei mir.


Weil du die relevanten Teile immer veränderst.

In deinem neuen Code: einem Pixel wird -1 zugewiesen, *wenn* er schon -1 hat. Klingt das sinnvoll?


----------



## Soltan (15. Jan 2018)

Draw und das arr sind eiegtnlich komplett unabhängige Digne voneinander. Draw. ist StdDraw und macht halt einfach nen Pixel irgendwo aber verändert nichts im array. Warum macht das einen Unterschied ob ich es nach oder vor der Veränderung des arrays stehen habe ? Ich habe es auch schon auf beide Arten probiert... Kommt dasselbe Ergebnis. Auskommentiert steht auch die Bedingung mit wenn er es nicht hat. Das funktioniert auch nicht.....


----------



## mrBrown (15. Jan 2018)

Mit Pixel meine ich den Pixel im Array.

Draw hat nichts mit dem Problem zu tun.

(Code nachträglich verändern ist btw echt doof -.-)


----------



## Soltan (15. Jan 2018)

Was habe ich denn verändert ?!


----------



## mrBrown (15. Jan 2018)

Soltan hat gesagt.:


> Was habe ich denn verändert ?!


Statt `klick` stand vorher `-1` dort?!
Deshalb steht in meinem Kommentar ne -1...

Oder meinst du, was du bei den überall zu findenden Algos verändert hast?


----------



## Meniskusschaden (15. Jan 2018)

Soltan hat gesagt.:


> Zu den Lösungen die überall zu finden sind: Tja die funktionieren eben nicht bei mir. Und ich habe keine Ahnugn warum.


Deshalb wäre es sinnvoll, mal einen Schreibtischtest zu machen. Dann würdest du feststellen, wo es zum Fehler kommt. Mit ein wenig Nachdenken müsstest du dann auch die Ursache erkennnen und dir eine Lösung ausdenken können. Außerdem solltest du diese "funktioniert nicht"-Beschreibungen dahingehend erweitern, dass du auch mal die Symptome zur Kenntnis nimmst, denn je nachdem, ob du beim Code aus #56 die aktive oder die auskommentierte Zeile verwendest, müsste das Problem unterschiedlich in Erscheinung treten - und beide Versionen unterscheiden sich vom urspünglichen Stapelüberlauf. Vielleicht ist das Kernproblem ja inzwischen gelöst und es ist nur noch ein banaler Fehler übrig. Ein "funktioniert nicht" kann durchaus ein Teilerfolg sein, wenn es nicht mehr dieselbe Ursache hat.


Soltan hat gesagt.:


> Dadurch dass es nur paar Zeilen sind bin ich auch am Ende zu suchen wo der Fehler liegen könnte.


Auch wenn es nur ein paar Zeilen sind, ist ein Schreibtischtest wegen der rekursiven Aufrufe schon ein wenig aufwändiger. Da genügt es nicht, sich die einzelnen Zeilen anzusehen, sondern man muß sie auch selbst manuell rekursiv ausführen und die Variablen in den verschiedenen Rekursionebenen korrekt führen.


Soltan hat gesagt.:


> Letztendlich hab ich dann schon einfach wild herum probiert aus Frustration.


Das ist völlig sinnlos. Strukturiertes Vorgehen ist gefragt.


----------



## Blender3D (15. Jan 2018)

Soltan hat gesagt.:


> if (imgArr[sy][sx]==klick)
> {
> imgArr[sy][sx]=klick;
> Draw(sx,sy,0.01);


Augenscheinlich schreibt Deine Funktion Draw an die Position sx, sy den Wert 0.01, das bedeutet Du musst für die Bedingung nach dem Farbwert prüfen den Dein Draw(sx,sy,0.01) zur Folge hat.


Die Idee des Algorithmus ist es die jeweilige Position mit dem gewünschten Farbwert zu vergleichen.
Falls dieser dort nicht gesetzt ist, soll er gesetzt und der Algorithmus für alle Nachbarpositionen aufgerufen werden. Andernfalls wird zurückgesprungen.


----------

