Maximale Stack Größe reicht nicht

[kub]

Hallo,

ich arbeite an einer Bildverarbeitungsapplikation, bei der ich ein Bild rekursiv untersuche. Bei Megapixel-bildern habe ich das Problem, dass es zu einer Zugriffsverletzung kommt, wenn sehr große Bereiche untersucht werden. Der Grund dafür ist die "Maximale Stackgröße". In den Projektoptionen kann mann höchstens $1000000 einstellen, was aber bei meiner Anwendung nicht reicht.
Mit {$MAXSTACKSIZE 90000000} im code, funktioniert es, wenn ich die so erstellte EXE direkt starte. Starte ich aber aus delphi heraus, bekomme ich wieder eine access violation. Kennt jemand eine Möglichkeit, das irgendwie zu umgehen?

Ich benutze übgrigens Delphi6.

Danke schon mal im Voraus.

Gruß
Thomas

[uligerhardt]

Bevor du an Stackgröße o.ä. drehst, würde ich mir erstmal überlegen, ob ich meinen Algorithmus oder seine Implementierung verbessern kann - lokale Variablen einsparen, Iteration statt Rekursion etc.
Ein Standardproblem bei Stacküberlauf sind vergessene const bei "großen" Übergabeparametern.

[Blup]

Die Bilddaten nicht auf dem Stack schieben, sondern nur eine Referenz auf diese im Speicher.
z.B.:

Delphi-Quellcode:

type
  PRiesigeDaten = ^TRiesigeDaten;
  TRiesigeDaten = record
    Werte: Array[1..unendlich]: Byte;
    NochMehrWerte: Integer;
  end;

procedure RekursiveRiesigeDaten(Daten: PRiesigeDaten);
var
  lDaten: PRiesigeDaten;
begin
  if not Abbruchbedingung then
  begin
    New(lDaten);
    try
      lDaten^ := Daten^;
      RekursiveRiesigeDaten(lDaten);
    finally
      Dispose(lDaten);
    end;
  end;
end;

[kub]

Ich sehe leider keine Möglichkeit die Funktion zu optimieren. Als Parameter übergebe ich nur x und y Koordinate als const integer und habe auch keine lokalen Variablen. Das Bild und die Ergebnisdaten sind Member der Suchklasse und werden nicht übergeben.
Die Funktion sucht zusammenhängende dunkle Bereiche. Das Bild wird dabei Zeile für Zeile nach einem Pixel gesucht, dessen Grauwert unterhalb eines Schwellwerts liegt. Wenn eines gefunden wurde, wird geprüft, ob eines der anliegenden Pixel auch der Bedingung entspricht. Wenn ja, muss ich wieder alle Pixel um dieses kontrollieren. Ich sehe nicht, wie das anders als rekursiv gelöst werden kann.

Delphi-Quellcode:

Procedure blob(const X: integer; const Y: integer);
begin
  if Bild[x][y].Grauwert < Schwellwert then
  begin    
    //gefundenes Pixel bzgl. Extrema und Schwerpunkt der Fläche verarbeiten 
    //..
    //damit Pixel nicht doppelt gezählt wird, Grauwert auf Maxwert (>Schwellwert) setzen
    Bild[x][y].Grauwert:= 255;
    //Umgebung nach weiteren zugehörigen Pixeln untersuchen 
    if (x < Bild.MaxX) then blob(x+1,y);
    if (x > 0) then blob(x-1,y);
    if (y < Bild.MaxY) then blob(x,y+1);
    if (x > 0) then blob(x,y-1);
  end;
end;

Falls jemand noch eine Idee zur Optimierung hat, wäre ich dankbar.

Wenn ich das Programm aus Delphi heraus starte, bekomme ich bis jetzt eine Meldung einer Zugriffsverletzung und dann hängt sich Delphi so auf (100% CPU Auslastung), dass ich es mit dem Task Manager beenden muss. Momentan achte ich darauf, beim Testen keine zu großen Flächen zu untersuchen, finde das aber ziemlich unbefriedigend.

[xZise]

Moin,
wie wäre da eine iterative Lösung?

Du scheinst ja zuerst nach rechts zu gehen, dann wieder zurück etc.? Übrigens bist du dir sicher, dass die letzte if-Bedingung so stimmt? Muss nach nicht y > 0 hin?

MfG
Fabian

[jfheins]

Zitat von kub:

Ich sehe nicht, wie das anders als rekursiv gelöst werden kann.

Na ... iterativ?
Du legst dir einen Stack oder eine Queue selber an (also eine liste, der Unterschied ist nur die Art des Zugriffs) und lässt dann eine Schleife laufen - und zwar solange bis die Liste leer ist. Da wo du bis jetzt die Funktion rekursiv aufgerufen hast, schiebst du die Daten einfach in die Liste.

[SirThornberry]

also wenn ich mir den oben geposteten Ausschnitt ansehen werden alle Pixel des Bildes per Rekursion durchlaufen. Ich hab für so etwas bisher immer eine Schleife verwendet (bzw. 2 Schleifen ineinander)
Dadurch würde auch das prüfen das setzen des Grauwert wegfallen was nach meiner Erkenntnis wohl nur gemacht wird um zu verhindern das ein Bildpunkt doppelt behandelt wird.

[kub]

Die letzte Abfrage muss natürlich auf y > 0 prüfen. Ist in meinem eigentlichen Code auch so.

Mit einer einfachen doppelten Schleife kann ich das Problem nicht lösen, da diese Flächen beliebige Formen haben können und es auch mehrere Flächen geben kann, d.h. ich muss wissen welches der Pixel zu welcher Fläche gehört. Bei solchen Formen (2 Blobs) geht es z.B. mit einer Schleife nicht:

XXX
XXX XXX XXX
XXX X XXX
XXXXXXXXX

Wegen dieser Form, muss ich auch immer alle Seiten überprüfen. Klar habe ich hier den Fall, dass ich auch das Pixel prüfe, von dem aus ich die Funktion aufgerufen habe, aber wenn ich das nicht machen möchte, müsste ich übergeben, aus welcher Richtung ich komme und hätte noch einen Parameter mehr, der wieder auf den Stack käme.
Um eine Endlosschleife handelt es sich nicht, da ich ja immer überprüfe, ob der Grauwert unter der schwelle liegt. Wenn er es tut, setzte ich den Wert auf den Maximalgrauwert, d.h. wenn ich wieder auf dieses Pixel zurückkomme wird die Funktion sofort abgebrochen, weil die Bedingung ja jetzt nicht mehr erfüllt ist.

@SirThornberry: Den Schwellwert muss ich immer prüfen, damit ich sehe, ob dieses Pixel zu der Fläche gehört, dessen Schwerpunkt ich ermitteln soll.

[kub]

Das Bild mit den X ging leider voll daneben. Nicht formatiert sah das anders aus. Darum hier ein jpg

[SirThornberry]

Bitte pushe nicht innerhalb von 24 Stunden sondern nutze bitte
2.3.2.4 - In der Ruhe liegt die Kraft: Kein "Pushen" von Beiträgen