Um kleinere Objekt zu eliminieren kannst du eventuell mit Median-Filter etc. vorverarbeiten, oder nach der Sobel-Segmentierung mit morphologischen Operatoren filtern.

Viele Grüße,

Tobias

#define Kontur_Max 0xFFFFFF
#define Kontur_Min 0xFFFF00

if ( rgbPixel < 0xFFFFFF && rgbPixel > 0xFFFF00 )
{
 ...   // Ziehe diesen Pixel für die Kontur-Bestimmung in Betracht.
}

MfG

1. Zunächst mal Gauss-Filter um gröbstes Rauschen zu eliminieren.
2. Segmentierung mit Grauwert-Diagramm. Bitmap daraus machen.
3. Sobel-Operator anwenden

So müsste das doch funktionieren, oder?
Hat mir jemand ein C++ Beispiel für die Segmentierung mit Grauwert-Diagramm?
Danke
Dom

In welches Forum sollte ich meinen Beitrag denn schreiben TheBigW?

#include <windows.h>
#include "cmyimg.h"

#define p2(x,y)  ((y - 1) * this->bmih.biWidth + x    ) * 3
#define p3(x,y)  ((y - 1) * this->bmih.biWidth + x + 1) * 3
#define p4(x,y)  ((y    ) * this->bmih.biWidth + x + 1) * 3
#define p5(x,y)  ((y + 1) * this->bmih.biWidth + x + 1) * 3
#define p6(x,y)  ((y + 1) * this->bmih.biWidth + x    ) * 3
#define p7(x,y)  ((y + 1) * this->bmih.biWidth + x - 1) * 3
#define p8(x,y)  ((y    ) * this->bmih.biWidth + x - 1) * 3
#define p9(x,y)  ((y - 1) * this->bmih.biWidth + x - 1) * 3

/**
 * Konstruktor 
 * @param w Breite des Bildes in Pixeln
 * @param h Höhe des Bildes in Pixeln
 * @param f Datenformat
 * Mögliche Werte:
 *      IMG_RGB - RotGrünBlau-Bild
 *      IMG_GBR - GrünBlauRot-Bild
 */
cMyImage::cMyImage (BITMAPINFOHEADER bm, int f, unsigned char *lpd) {

    CopyMemory(&this->bmih, &bm, sizeof(BITMAPINFOHEADER)); 
    format  = f;

    /* Speicher auf bild legen */
    this->imgsize = this->bmih.biSizeImage;
//    this->lpdata = new unsigned char [imgsize];

    DIBSec  = CreateDIBSection( NULL, (BITMAPINFO *) &bmih, 
                                        DIB_RGB_COLORS, (void**)&lpdata, 
                                        NULL, 0
                                      );
    CopyMemory ((LPVOID) lpdata, (LPVOID) lpd, imgsize);

    switch (format) { 
        /* Indize für das jeweilige Datenformat beschreiben */
        case IMG_RGB:
                indexR = 0;
                indexB = 1;
                indexG = 2;
                break;
        case IMG_GBR:
                indexR = 2;
                indexB = 1;
                indexG = 0;
                break;
    }
}
/**
 * Destructor
 */
cMyImage::~cMyImage () { 
    /* Speicher freigeben */
    DeleteObject(DIBSec);
    delete lpdata;
}

/**
 * Konvertieren des Bildes nach Grauwertbild
 * @return cMyImage mit Grauwertbild
 */       
cMyImage *cMyImage::convertToGrayScale (void) {
    int width   = bmih.biWidth,
        height  = bmih.biHeight;
    int i, a, index;
    unsigned char *dummy = new unsigned char [imgsize];

    for (a = 0; a < height; a++) {
        for (i = 0; i < width; i++) {
            index = (a * width + i) * 3;
            dummy[index]   = (unsigned char)(0.56 * lpdata[index + indexR] + 0.11 * lpdata[index + indexG] + 0.33 * lpdata[index + indexB]);
            dummy[index + 1]  = dummy[index];
            dummy[index + 2]  = dummy[index];
        }
    }
    return new cMyImage(this->bmih, this->format, dummy);
}

/**
 * Filtern des Bildes
 * @return cMyImage mit gefiltertem Bild
 * @param op Filteroperator
 * @param opSize Größe des Operators (Seitenlänge)
 * @param flag Flags für den Filter. 
 * Mögliche Werte: 
 *      FIL_ABS - Absoluter Wert
 *      FIL_EQU - Normalisieren des Ergebnisses
 */
cMyImage *cMyImage::filter (int *op, int opSize, int flag) {
    int width   = bmih.biWidth,
        height  = bmih.biHeight;

    int a, i, sa, si, index, indexop;
    int d[3];
    unsigned char *dummy = new unsigned char [imgsize];
    memset (dummy, 0, imgsize);

    /* for each pixel */
    for (a = (opSize / 2); a < height - (opSize / 2); a++) {
        for (i = (opSize / 2); i < width - (opSize / 2); i++) {
            d[0] = 0;
            d[1] = 0;
            d[2] = 0;

            index = (a * width + i ) * 3;

            for (sa = 0; sa < opSize; sa++) {
                for (si = 0; si < opSize; si++) {
                    indexop = ((a + sa) * width + (i + si)) * 3;

                    d[indexR] += lpdata[indexop + indexR] * op[sa * opSize + si];
                    d[indexG] += lpdata[indexop + indexG] * op[sa * opSize + si];
                    d[indexB] += lpdata[indexop + indexB] * op[sa * opSize + si];
                }    
            }

            if (flag & FIL_EQU) {
                d[indexR] /=  (opSize * opSize);
                d[indexG] /=  (opSize * opSize);
                d[indexB] /=  (opSize * opSize);
            }
            if (flag & FIL_ABS) {
                 d[indexR] = abs(d[indexR]);  
                 d[indexG] = abs(d[indexG]);  
                 d[indexB] = abs(d[indexB]);  
            }

            dummy[index + indexR]     = d[indexR];
            dummy[index + indexG]     = d[indexG];
            dummy[index + indexB]     = d[indexB];
        }
    }
    return new cMyImage(this->bmih, this->format, dummy);
}

/**
 * Schwellwert für RGB festsetzen
 * @return cMyImage mit 0xffffff oder 0x000000 als Farbwerten
 */
cMyImage *cMyImage::trigger (unsigned char r, unsigned char g, unsigned char b)
{
    int width   = bmih.biWidth,
        height  = bmih.biHeight;
    int i, a, index;
    unsigned char *dummy = new unsigned char [imgsize];
    memset (dummy, 0, imgsize);

    for (a = 0; a < height; a++) {
        for (i = 0; i < width; i++) {
            index = (a * width + i) * 3;
            if (lpdata[index + indexR] > r) {
                dummy[index + indexR]   =  0xff;
            }
            if (lpdata[index + indexG] > g) {
                dummy[index + indexG]   =  0xff;
            }
            if (lpdata[index + indexB] > b) {
                dummy[index + indexB]   =  0xff;
            }
        }
    }
    return new cMyImage(this->bmih, this->format, dummy);
}
/**
 * Ausdünnen der Linien 
 * @return cMyImage mit ausgedünnten Linien
 */
cMyImage *cMyImage::thin ()
{
    int width   = bmih.biWidth,
        height  = bmih.biHeight;
    int i, a, A, B, index;

    unsigned char *dummy = new unsigned char [imgsize];
    memset (dummy, 0, imgsize);

    for (a = 2; a < height - 2; a++) {
        for (i = 2; i < width - 2; i++) {
            index = (a * width + i) * 3;
            if (lpdata[index]) {
                A = calcBorders (i, a);
                B = calcNeighbours (i, a);

                if (
                        ((B > 2 && B < 6) || B == 0 ) 
                    ||  (A == 1)
                    || (
                       (
                        (
                               (!lpdata[p2(i, a)]) 
                            && (!lpdata[p4(i, a)]) 
                            && (!lpdata[p8(i, a)])
                        ) 
                        || calcBorders(i, a -1) != 1
                        )
                    && (
                        (
                               (!lpdata[p2(i, a)]) 
                            && (!lpdata[p4(i, a)]) 
                            && (!lpdata[p6(i, a)])
                        ) 
                        || calcBorders(i - 1, a) != 1
                       )
                      ) 
                   ) {
                    dummy [index] = 0;
                    dummy [index + 1] = 0;
                    dummy [index + 2] = 0;
                } else {
                    dummy [index] = lpdata[index];
                    dummy [index + 1] = lpdata[index + 1];
                    dummy [index + 2] = lpdata[index + 2];
                }
            } else {
                dummy [index] = lpdata[index];
                dummy [index + 1] = lpdata[index + 1];
                dummy [index + 2] = lpdata[index + 2];
            }
        }
    }
    return new cMyImage(this->bmih, this->format, dummy);
}

/**
 * Darstellen
 * @param hWnd Fenster auf das gemalt werden soll
 * @param x position x
 * @param y position y
 */
void cMyImage::blit (HDC hDC, int x, int y) {

    HDC     iDC = CreateCompatibleDC(hDC);

//	CopyMemory (d, lpdata, bmih.biSizeImage);
    SelectObject(iDC, DIBSec);

    BitBlt(hDC, x, y, this->bmih.biWidth, this->bmih.biHeight, iDC, 0, 0, SRCCOPY );

    DeleteDC(iDC);

}

/**
 * Speichern des Bildes in eine Datei
 * @param fileName - Dateiname
 */
/*
void cMyImage::saveBitmap(char *fileName) {
	// Save To Bitmap File
}
void  cMyImage::loadBitmap(char fileName) {

}
*/
/**
 * Anzahl Grenzfelder berechnen
 */
unsigned int cMyImage::calcBorders (int x, int y){
    int d = 0;
    if (lpdata[p2(x, y)] != 0 && (0 == lpdata[p9(x, y)] ) ) d++;
    if (lpdata[p3(x, y)] != 0 && (0 == lpdata[p2(x, y)] ) ) d++;
    if (lpdata[p4(x, y)] != 0 && (0 == lpdata[p3(x, y)] ) ) d++;
    if (lpdata[p5(x, y)] != 0 && (0 == lpdata[p4(x, y)] ) ) d++;
    if (lpdata[p6(x, y)] != 0 && (0 == lpdata[p5(x, y)] ) ) d++;
    if (lpdata[p7(x, y)] != 0 && (0 == lpdata[p6(x, y)] ) ) d++;
    if (lpdata[p8(x, y)] != 0 && (0 == lpdata[p7(x, y)] ) ) d++;
    if (lpdata[p9(x, y)] != 0 && (0 == lpdata[p8(x, y)] ) ) d++;

    return d;
}
/**
 * Anzahl Nachbarfelder berechnen
 */
unsigned int cMyImage::calcNeighbours (int x, int y)
{
    int d = 0;
    if (lpdata[p2(x, y)] != 0 ) d++;
    if (lpdata[p3(x, y)] != 0 ) d++;
    if (lpdata[p4(x, y)] != 0 ) d++;
    if (lpdata[p5(x, y)] != 0 ) d++;
    if (lpdata[p6(x, y)] != 0 ) d++;
    if (lpdata[p7(x, y)] != 0 ) d++;
    if (lpdata[p8(x, y)] != 0 ) d++;
    if (lpdata[p9(x, y)] != 0 ) d++;

    return d;
}

1. Zunächst mal Gauss-Filter um gröbstes Rauschen zu eliminieren.

soviel ich weiß ist es in dem fall besser 'nen medianfilter auf das bild anzuwenden, da bei 'nem unschärfefilter erstens die störungen nur verwischt werden und die energie im bild erhalten bleibt und zweitens - und das ist viel gravierender - auch die kanten mitgeschwächt werden.

Um störende "kleine" Objekte zu entfernen dann am Ende eher morphologische Filter. Einfach gesagt, eine Art Sieb -> kleine Objekte fallen Durch, große bleiben übrig.

der Gauss-Filter verwischt (wie Ihr schon geschrieben habt) tatsächlich auch die Kante. -Hab mal rumgelesen.
Die Hough-Transformation ist laut meiner Bildverarbeitungsliteratur zu rechenintensiv für Zeitkritische Systeme (und das habe ich).
Ich denke ich werde es mit Erosion und Dilatation probieren, da bleibt mir anscheinend die Kante erhalten und die Störenden Flecken verschwinden. -Ich bin mir nur unsicher ob das nicht auch sehr rechenintensiv ist???
-Falls noch jamand eine Idee hat (-oder Quellcode) ...gerne.
Danke nochmal
Dom