Eclipse Stackoverflow beim Einlesen von großen Bilder in kd Baum

Megara

Mitglied
Hallo liebe Java Freunde,
Bin neu hier im Forum und ich hoffe ihr könnt mir bei meinem Problem weiterhelfen.

Möchte gerne Farbinformationen aus einem beliebigem Bild auslesen und in einem kd Baum speichern nach den RGB Werten. Bei kleinen Bildern (Bsp. 150x150 oder 400x276) klappt es gut aber bei grösseren Bildern (Bsp. 1024x1024) bekomme ich Stackoverflow. Wie kann ich das Problem bereinigen.

Farbobjekt.java
Java:
import java.awt.Color;


public class Farbobjekt {
	
	// RGB Farbwerte
	private int Rot;
	private int Gruen;
	private int Blau;
	
	// X,Y Koordinaten
	private int X;
	private int Y;
	
	// Konstruktor
	public Farbobjekt(Color c){//, Point p){
		this.Rot = c.getRed();
		this.Gruen = c.getGreen();
		this.Blau = c.getBlue();
		//this.X = p.x;
		//this.Y = p.y;
	}
	
	// gibt den Rotwert des Farbobjekts zurück
	public int getRot(){
		return Rot;
	}
	
	// gibt den Grünwert des Farbobjekts zurück
	public int getGruen(){
		return Gruen;
	}
	
	// gibt den Blauwert des Farbobjekts zurück
	public int getBlau(){
		return Blau;
	}
	
	// gibt die X Koordinate des Farbobjekts zurück
	public int getX(){
		return X;
	}
	
	// gibt die Y Koordinate des Farbobjekts zurück
	public int getY(){
		return Y;
	}
	
	public String toString(){
		return "R : " + this.Rot + " G : " + this.Gruen + " B : " + this.Blau;
	}
}

Knoten.java
Java:
/*
 * Ein Knoten eines kd-Baums enthält ein Farbobjekt
 */

public class Knoten {
	
	public Knoten links;
	public Knoten rechts;
	
	private Farbobjekt pixel;
	
	// Konstruktor
	public Knoten(Farbobjekt pixel){
		this.pixel = pixel;
		this.links = null;
		this.rechts = null;
	}
	
	// gibt im Knoten gespeichertes Farbobjekt zurück
	public Farbobjekt getPixel(){
		return pixel;
	}

}

KdBaum.java
Java:
public class KdBaum {

	Knoten wurzel;

	// Konstruktor
	public KdBaum(){
		wurzel = null;
	}

	public void erstellen(Farbobjekt neuPixel){
		wurzel = einfuegen(wurzel, neuPixel, 0);
	}

	/*
	 * einfuegen = fügt einen neuen Knoten in den kd Baum ein
	 * ist die Wurzel "null" wird der aktuelle Knoten als Wurzel festgelegt
	 * Ebene 0 : der Rot Wert wird verglichen.
	 * Ebene 1 : der Grün Wert wird verglichen
	 * Ebene 2 : der Blau Wert wird verglichen
	 * ist der Wert (R,G,B) des neuen Knotens <= als der Wert des aktuellen Knotens wird der
	 * neue Knoten links in den kd Baum eingefügt.
	 * ist der Wert (R,G,B) des neuen Knotens > als der Wert des aktuellen Knotens wird der
	 * neue Knoten rechts in den kd Baum eingefügt. 
	 */
	private Knoten einfuegen(Knoten aktuellerKnoten, Farbobjekt neuPixel, int ebene){
		if(aktuellerKnoten == null){
			aktuellerKnoten = new Knoten(neuPixel);
		}
		else{
			//System.out.println("Ebene " + ebene);
			switch(ebene % 3){
			case 0 :
				if(neuPixel.getRot()<=aktuellerKnoten.getPixel().getRot()){
					//System.out.println("Ebene : " + ebene + " " + aktuellerKnoten.getPixel().getRot() + " Links " + neuPixel.getRot());
					aktuellerKnoten.links = einfuegen(aktuellerKnoten.links, neuPixel, ebene+1);										
				}
				else{
					//System.out.println("Ebene : " + ebene + " " + aktuellerKnoten.getPixel().getRot() + " Rechts " + neuPixel.getRot());
					aktuellerKnoten.rechts = einfuegen(aktuellerKnoten.rechts, neuPixel, ebene+1);
				}
				break;
			case 1 :
				if(neuPixel.getGruen()<=aktuellerKnoten.getPixel().getGruen()){
					//System.out.println("Ebene : " + ebene + " " + aktuellerKnoten.getPixel().getGruen() + " Links " + neuPixel.getGruen());
					aktuellerKnoten.links = einfuegen(aktuellerKnoten.links, neuPixel, ebene+1);										
				}
				else{
					//System.out.println("Ebene : " + ebene + " " + aktuellerKnoten.getPixel().getGruen() + " Rechts " + neuPixel.getGruen());
					aktuellerKnoten.rechts = einfuegen(aktuellerKnoten.rechts, neuPixel, ebene+1);
				}
				break;
			case 2 :
				if(neuPixel.getBlau()<=aktuellerKnoten.getPixel().getBlau()){
					//System.out.println("Ebene : " + ebene + " " + aktuellerKnoten.getPixel().getBlau() + " Links " + neuPixel.getBlau());
					aktuellerKnoten.links = einfuegen(aktuellerKnoten.links, neuPixel, ebene+1);										
				}
				else{
					//System.out.println("Ebene : " + ebene + " " + aktuellerKnoten.getPixel().getBlau() + " Rechts " + neuPixel.getBlau());
					aktuellerKnoten.rechts = einfuegen(aktuellerKnoten.rechts, neuPixel, ebene+1);
				}
				break;
			}
		}
		return aktuellerKnoten;
	}

	public void KnotenListe(){
		Preorder(wurzel,0);
	}

	private void Preorder(Knoten aktuell, int ebene){
		if(aktuell != null){
			System.out.println("Ebene : " + ebene + " " + aktuell.getPixel().toString());
			Preorder(aktuell.links,ebene++);
			Preorder(aktuell.rechts,ebene++);
		}
	}
}

Main.java
Java:
import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class Main {
	
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub		
		KdBaum Baum = new KdBaum();
		BufferedImage img = ImageIO.read(new File("C:/Bild.jpg")); // 1024x1024
		//BufferedImage img = ImageIO.read(new File("C:/Bild1_klein.jpg")); // 150x150
		//BufferedImage img = ImageIO.read(new File("C:/Bild4.jpg")); // 400x276
		for(int i=0;i<img.getWidth();i++){
			for(int j=0;j<img.getHeight();j++){
				int rgb = img.getRGB(i,j);
				Color c = new Color(rgb);
				Farbobjekt PixelFarbe = new Farbobjekt(c);
				Baum.erstellen(PixelFarbe);
			}
		}
		Baum.KnotenListe();
	}
}

Problem Bild (1024x1024) im Anhang ^^

Danke für eure Hilfe 🙂
Gruß,
Megara
 
Deine Rekursion in der Methode einfuegen ist zu tief. Entweder begnügst du dich mit kleineren Bildern oder du musst die Rekursion auflösen und die Methode iterativ implementieren.
 
Run -> Run Configuration -> den "Reiter" (X)=Arguments -> im Feld VM-Arguments -Xss10m eingeben und applien
 
Danke für deine Hilfe.

Habe das wie angegeben beim Projekt angegeben. Dadurch wird mein Laptop und das Programm langsam. Hab mal einen Screenshot gemacht für den Fall falls ich es an der falschen Stelle angegeben habe.

Gruss,
Megara
 
ist das Programm auch mit kleinen Bildern langsamer?
mit dem großen stürzte es vorher ab, das ist ja nicht unbedingt zu vergleichen,
1 Mio. Pixel sind nunmal etwas Arbeit, gerade mit Bildern hat Java zu tun
 
evtl. solltest du dir überlegen, ob du das überhaupt willst und es dein Problem löst.

-Xss = the stack size for each thread
-Xms = initial java heap size
-Xmx = maximum java heap size
-Xmn = the size of the heap for the young generation

oder ob dir nicht eines der anderen VM-Arguments eher hilft?!
ich bin da nicht so in der Materie firm, sondern konnte dir nur sagen, wo du es bei eclipse einfügen musst.
Evtl. auch eine Kombination aus den möglichen Argumenten...?!
 
Danke Jungs für eure Hilfe.
Bei kleineren Bilder mit vielen Farben hat das Program keine Probleme. Nur bei größeren Bilder und bei Bilder mit vielen gleichen Farben (Bsp. Vereinslogo BVB -> viel Gelb) tritt das Problem mit dem Stackoverflow auf.
 
ist das Thema beendet?
bitte immer ganz genau aufpassen was du in deine Postings schreibst, möglichst eindeutig formulieren
 
ist das Thema beendet?
bitte immer ganz genau aufpassen was du in deine Postings schreibst, möglichst eindeutig formulieren

Das Thema ist noch nicht beendet. Würde mich über weitere Lösungsansätze sehr freuen.
Das Problem mit dem Stack overflow tritt noch bei folgenden Bilder auf:
Bei kleineren Bilder mit vielen Farben hat das Program keine Probleme. Nur bei größeren Bilder und bei Bilder mit vielen gleichen Farben (Bsp. Vereinslogo BVB -> viel Gelb) tritt das Problem mit dem Stackoverflow auf.

Gruss,
Megara
 
zwei Tipps habe ich noch, zum einen:
die erhöhte StackSize kann sich evtl. nur auf neu gestartete Threads beziehen, nicht auf den main-Thread,
Testprogramm:
Java:
public class Test {
    public static void main(String[] args)  {
        Runnable r = new Runnable()    {
                public void run()   {
                    A a = new A();
                    try  {
                        a.test();
                    }   catch (Throwable e)  {   }
                    System.out.println(a.k + ", " + Thread.currentThread());
                }
            };

        new Thread(r).start();
        r.run();
    }
}

class A {
    int k;

    void test()  {
        k++;
        test();
    }
}
Ausgabe bei mir mit -Xss10m:
Code:
10922, Thread[main,5,main] // wenig für main
519139, Thread[Thread-0,5,main] // viel für neuen Thread

-----------

zum anderen aber, viel wichtiger:
fast kein Programm sollte tausende ineinander geschachtelte Methodenaufrufe haben,
Rekursion kann man auch immer durch Schleifen ersetzen, und sei es while(true) zusammen mit dynamisch gesetzen Variablen,

kennst du den A*-Algorithmus?
A*-Algorithmus ? Wikipedia
da läuft auch nur eine riesige Schleife, neue zu bearbeitende Knoten werden in eine Liste eingefügt und nach und nach herausgeholt,
beim nächsten Schleifendurchlauf

wenn du in einem 1000x1000 Quadrat herumläufst, was auch immer du da machst, kannst du vielleicht mit Schleifen und Indexen noch geordneter vorgehen
 
Die Wahl der Programmiersprache ist freigestellt. Auch freigestellt ist, ob Sie reale Bilder verwenden oder Bilder einfach durch 2-*‐dim. Arrays simulieren.
dann verwende doch fürs erste ein 2-dim Array mit einer wie im Bsp benutzen 8x8 Matrix?!
 

Zurück
Oben