Hallo,
dies ist mein erster Post in diesem Forum, habe mir schon viele Threads vorher durchgelesen, aber leider keine brauchbare Antwort für mein Problem gefunden. Nun hoffe ich hier auf die Hilfe eines anderen ???:L
Erstmal zur Ausgangssituation:
Ich habe ein Bild mit nur Vordergrund- und Hintergrundpixeln. Die weißen Pixel sind der Hintergrund, die schwarzen der Vordergrund. Die Vordergrundpixel bilden stark ausgedünnte Konturen, die nur ein Pixel breit sind. Ich möchte nun diese Konturstücke finden und in Listen abspeichern, um diese anschließend zu analysieren. Dazu verfolge ich folgenden Ansatz:
1. Ich durchlaufe das Bild mit zwei for-Schleifen und suche nach einem Vordergrundpixel.
2. Ist dies gefunden hangel ich mich von diesem Pixel über seine Nachbarpixel solange vorwärts, bis ich eins gefunden habe, das nur einen Nachbarn hat. Also den Anfang eines Konturstücks darstellt.
3. Nun möchte ich von dort die komplette Kontur ablaufen und jedes Vordergrundpixel in einer Liste ablegen, bis ich das andere Ende der Kontur erreicht habe. Dann speicher ich dieses Konturstück wiederum in einer Liste, die alle Konturstücken des Bildes verwaltet.
Der bisherige Quell-Code dazu:
Die Klasse ByteProcessor ist eine Klasse aus dem Package von ImageJ, muss aber hier nicht weiterbeachtet werden.
Vielleicht kann mir hierbei jemandweiterhelfen, da ich momentan den Wald vor lauter Bäumen nicht sehe ???:L
dies ist mein erster Post in diesem Forum, habe mir schon viele Threads vorher durchgelesen, aber leider keine brauchbare Antwort für mein Problem gefunden. Nun hoffe ich hier auf die Hilfe eines anderen ???:L
Erstmal zur Ausgangssituation:
Ich habe ein Bild mit nur Vordergrund- und Hintergrundpixeln. Die weißen Pixel sind der Hintergrund, die schwarzen der Vordergrund. Die Vordergrundpixel bilden stark ausgedünnte Konturen, die nur ein Pixel breit sind. Ich möchte nun diese Konturstücke finden und in Listen abspeichern, um diese anschließend zu analysieren. Dazu verfolge ich folgenden Ansatz:
1. Ich durchlaufe das Bild mit zwei for-Schleifen und suche nach einem Vordergrundpixel.
2. Ist dies gefunden hangel ich mich von diesem Pixel über seine Nachbarpixel solange vorwärts, bis ich eins gefunden habe, das nur einen Nachbarn hat. Also den Anfang eines Konturstücks darstellt.
3. Nun möchte ich von dort die komplette Kontur ablaufen und jedes Vordergrundpixel in einer Liste ablegen, bis ich das andere Ende der Kontur erreicht habe. Dann speicher ich dieses Konturstück wiederum in einer Liste, die alle Konturstücken des Bildes verwaltet.
Der bisherige Quell-Code dazu:
Die Klasse ByteProcessor ist eine Klasse aus dem Package von ImageJ, muss aber hier nicht weiterbeachtet werden.
Code:
public class ContourFinder
{
static final int BLACK = 0;
int width;
int height;
int tempU;
int tempV;
//Liste gefüllt mit Konturen
Contour contour;
List<Contour> contourList = new ArrayList<Contour>();
//stellt den ByteProcessor zur Verfügung
ByteProcessor byteProcessor;
public ContourFinder(ByteProcessor byteProcessor)
{
this.byteProcessor = byteProcessor;
}
//*****************************************************************************
//Methode zum Finden und Abspeichern einer Kontur
public void findContour()
{
width = byteProcessor.getWidth();
height = byteProcessor.getHeight();
for (int u = 0; u <= width; u++)
{
for (int v = 0; v <= height; v++)
{
if (byteProcessor.getPixel(u, v) == BLACK)
{
//sucht dann Anfang einer Kontur
if (countBlackNeighbours(u, v) == 1)
{
followContour(u, v);
}
}
}
}
}
//*****************************************************************************
//überprüft die Nachbarpixel nach dem Wert 'BLACK' und gibt deren Anzahl zurück
private int countBlackNeighbours(int u, int v)
{
int numberOfNeighbours = 0;
for (int i = u-1; i <= u+1; i++)
{
for (int j = v-1; j <= v+1; j++)
{
//der Pixel muss Schwarz sein, darf nicht er selbst sein, d.h. nicht
//in der Mitte liegen und muss innerhalb der Bildbereichs liegen
if (byteProcessor.getPixel(i, j) == BLACK
&& !(i == u && j == v)
&& !(i < 0 || i > width-1 || j < 0 || j > height-1))
{
numberOfNeighbours++;
}
}
}
return numberOfNeighbours;
}
//*****************************************************************************
//folgt einer Kontur solange bis ihr Ende erreicht ist und speichert dabei jeden
//Pixel der Kontur in einer Liste ab
private void followContour(int u, int v)
{
contour = new Contour();
do
{
for (int i = u-1; i <= u+1; i++)
{
for (int j = v-1; j <= v+1; j++)
{
//der Pixel muss Schwarz sein, darf nicht besucht sein
//und muss innerhalb der Bildbereichs liegen
if (byteProcessor.getPixel(i, j) == BLACK
//hier müsste noch geprüft werden ob der Pixel schon in einer Liste abgelegt ist
&& !(i == u && j == v)
&& !(i < 0 || i > width || j < 0 || j > height))
{
pixel = new Pixel(i, j);
pixel.visited = true;
pixel.numberOfNeighbours = countBlackNeighbours(i, j);
contour.pixelList.add(pixel);
//Zwischenspeicherung der Koordinaten des letzten VG-Pixels
tempU = i;
tempV = j;
}
}
}
u = tempU;
v = tempV;
//byteProcessor.putPixel(pixel.posX, pixel.posY, 200);
}
while(countBlackNeighbours(u, v) > 1);
//speichert die komplette Pixelliste in der Konturliste
contourList.add(contour);
}
Code:
//zur Verwaltung der Konturen aus Bildpunkten
class Contour
{
List<Pixel> pixelList;
int length;
Contour()
{
pixelList = new ArrayList<Pixel>();
length = pixelList.size();
}
Code:
class Pixel
{
int posX;
int posY;
int numberOfNeighbours;
boolean visited;
Pixel() {
//parameterloser Konstrukter
}
Pixel(int posX, int posY)
{
this.posX = posX;
this.posY = posY;
}
}Vielleicht kann mir hierbei jemandweiterhelfen, da ich momentan den Wald vor lauter Bäumen nicht sehe ???:L
