Przetwarzanie obrazów - binaryzacja

[kwgrkwgr]

Chciałbym zrobić sobie aplikację na wejściu której wczytuje obrazek (bmp lub inny). I obrazek zostaje przetworzony funkcją która ustala próg odcięcia informacji użytkowej od reszty. Znalazłem jedną taką funkcję którą mógłbym wykorzystać lecz nie wiem jak przerobić z C# na C++ oraz jakie funkcje z math.hpp wykorzystać.

Link źródłowy to:
http://en.wikipedia.org/wiki/Otsu's_method
http://www.codeproject.com/KB/graphics/OtsuSharp.aspx [kod źródłowy]

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

Bitmap temp = (Bitmap)org.Clone();
ot.Convert2GrayScaleFast(temp);
int otsuThreshold= ot.getOtsuThreshold((Bitmap)temp);
ot.threshold(temp,otsuThreshold);
textBox1.Text = otsuThreshold.ToString();
pictureBox1.Image = temp;

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

public int getOtsuThreshold(Bitmap bmp)
{
    byte t=0;
    float[] vet=new float[256];
    int[] hist=new int[256];
    vet.Initialize();

    float p1,p2,p12;
    int k;

    BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
    ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
    unsafe
    {
        byte* p = (byte*)(void*)bmData.Scan0.ToPointer();

        getHistogram(p,bmp.Width,bmp.Height,bmData.Stride, hist);

       
        for (k = 1; k != 255; k++)
        {
            p1 = Px(0, k, hist);
            p2 = Px(k + 1, 255, hist);
            p12 = p1 * p2;
            if (p12 == 0)
                p12 = 1;
            float diff=(Mx(0, k, hist) * p2) - (Mx(k + 1, 255, hist) * p1);
            vet[k] = (float)diff * diff / p12;
           
        }
    }
    bmp.UnlockBits(bmData);

    t = (byte)findMax(vet, 256);

    return t;
}

W C# pisałem na razie mało.
http://chomikuj.pl/kwgr/Ciekawostki/Ots ... 529825.zip C#

Dzięki za pomoc w przerobieniu funkcji.

[polymorphism]

No a gdzie jakiś wkład własny? Funkcja nie wygląda na jakąś strasznie skomplikowaną, zatem jeśli znasz składnie C++, to nie powinno być większego problemu ze zrozumieniem tego kodu i przerobieniem go. Różnice zaczynają się w użytych klasach bibliotecznych. Ale tu też nie widzę jakiegoś dużego problemu, po prostu zamiast klasy Bitmap, użyj TBitmap. Zamiast metody ToPointer, użyj właściwości ScanLine. Itd, itp...

[Cyfrowy Baron]

Czy to nie jest przypadkiem konwersja bitmapy szarej na monochromatyczną? Jeżeli tak to podałem już rozwiązanie w serwisie Cyfrowy Baron w dziale: porady grafika konwersja bitmapy na szarą i monochromatyczną.

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

Graphics::TBitmap *bmp = new Graphics::TBitmap;
 bmp->LoadFromFile("E:\\Grafika\\Archer.bmp");
 bmp->PixelFormat = pf8bit;

 for(int x = 0; x < bmp->Height; x++)
 {
  RGBQUAD *piksel = (RGBQUAD *) bmp->ScanLine[x];
  for(int y = 0; y < bmp->Width; y++, piksel++)
  {
   int r = piksel->rgbRed;
   int g = piksel->rgbGreen;
   int b = piksel->rgbBlue;
   int z = piksel->rgbReserved;

   if(r > 128) r = 255; else r = 0;
   if(g > 128) g = 255; else g = 0;
   if(b > 128) b = 255; else b = 0;
   if(z > 128) z = 255; else z = 0;

   piksel->rgbRed   = (BYTE)r;
   piksel->rgbGreen = (BYTE)g;
   piksel->rgbBlue  = (BYTE)b;
   piksel->rgbReserved = (BYTE)z;
  }
 }

 Image1->Picture->Assign(bmp);
 Image1->Picture->Bitmap->PixelFormat = pf1bit;
 Image1->Picture->SaveToFile(ExtractFilePath(ParamStr(0)) + "grafika.bmp");

Prób konwersji koloru szarego na biały lub czarny jest regulowany w warunkach:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

   if(r > 128) r = 255; else r = 0;
   if(g > 128) g = 255; else g = 0;
   if(b > 128) b = 255; else b = 0;
   if(z > 128) z = 255; else z = 0;

Tutaj 128, czyli prawie połowa zakresu z 255.

[kwgrkwgr]

Czy to nie jest przypadkiem konwersja bitmapy szarej na monochromatyczną?

Tak lecz chodzi o dobór progu który jest liczony wg algorytmu Otsu lub innych. Ogólnodostępny plik PDF to: http://www.mif.pg.gda.pl/homepages/marcin/Wyklad3.pdf

To co udało mi się przekształcić z C# na C++ wygląda tak:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//------------------------------------------------------------------------------
int findMax(float *vec, int n)
                {
                        float maxVec = 0;
                        int idx=0;
                        int i;

                        for (i = 1; i < n - 1; i++)
                        {
                                if (vec[i] > maxVec)
                                {
                                        maxVec = vec[i];
                                        idx = i;
                                }
                        }
                        return idx;
                }
//------------------------------------------------------------------------------
float Mx(int init, int end, int *hist)
                {
                        int sum = 0;
                        int i;
                        for (i = init; i <= end; i++)
                                sum += i * hist[i];

                        return (float)sum;
                }
//------------------------------------------------------------------------------
float Px(int init, int end, int *hist)
                {
                        int sum = 0;
                        int i;
                        for (i = init; i <= end; i++)
                                sum += hist[i];

                        return (float)sum;
                }
//------------------------------------------------------------------------------
int TProgowanie::getOtsuThreshold()
{
  int t, t_cz, t_b;

  int x, y, tmp_x, i;
  BYTE* LinePtr;
  int hist[256];

  if (Progowanie->Image1->Picture->Bitmap->PixelFormat == 6)
  {
        i = 3;
  }
  else
  {
        i = 1;
  }

  // obliczanie histogramu
  for (x = 0; x < 256; x++) hist[x] = 0;

  for (y = 0; y < Progowanie->Image1->Picture->Bitmap->Height; y++)
  {
        LinePtr = (BYTE*) Progowanie->Image1->Picture->Bitmap->ScanLine[y];
        for (x = 0; x < i * Progowanie->Image1->Picture->Bitmap->Width; x = x + i)
        {
          if (Progowanie->Image1->Picture->Bitmap->PixelFormat == 6)
          {
                tmp_x = (LinePtr[x] + LinePtr[x + 1] + LinePtr[x + 2]) / 3;
          }
          else
          {
                tmp_x = LinePtr[x];
          }
          hist[tmp_x]++;
        }
  }
  // koniec hist

        //byte t=0;
        float vet[256];   // byłło: int vet[256]; a wówczas wynik końcowy nie zawsze był OK
        //int hist[256];

        float p1,p2,p12;
        int k;
                for (k = 1; k != 255; k++)
                {
                        p1 = Px(0, k, hist);
                        p2 = Px(k + 1, 255, hist);
                        p12 = p1 * p2;
                        if (p12 == 0)
                                p12 = 1;
                        float diff=(Mx(0, k, hist) * p2) - (Mx(k + 1, 255, hist) * p1);
                        vet[k] = (float)diff * diff / p12;
                        //vet[k] = (float)Math.Pow((Mx(0, k, hist) * p2) - (Mx(k + 1, 255, hist) * p1), 2) / p12;
                }
        Edit5->Text = (byte)MaxIntValue(vet,256);
}

Daje rezultat końcowy lecz nie rozumie tej ostatniej lin linijki:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

t = (byte)findMax(vet, 256); //to mi nie działa i nie wiem dlaczego zabardzo (cannot convert ...)

Dlatego skorzystałem z math.hpp i funkcji MaxIntValue.

Może komuś ten kawałek kody się przyda? I biorę się za kolejne metody opisane w tym pliku PDF.

[Cyfrowy Baron]

Rozwiązanie już Tobie podałem, teraz dorób do tego algorytm i nie potrzebujesz niczego więcej, wszak wszystko sprowadza się do pikseli, albo dajesz piksel czarny, albo biały, przypisywanie pikseli odbywa się tutaj:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

   if(r > 128) r = 255; else r = 0;
   if(g > 128) g = 255; else g = 0;
   if(b > 128) b = 255; else b = 0;
   if(z > 128) z = 255; else z = 0;

Z algorytmem nie pomogę, gdyż kiepsko sobie radzę z tym...

[kwgrkwgr]

Co do algorytmu to zwraca jakiś próg, nie wiem czy jest dobry czy zły ale jakiś jest i mi to wystarcza. Mam problem jak zrobić tą funkcję progującą. Mam coś takiego lecz jest błąd podczas wykonania, kompilacja przechodzi. Czy jest możliwe by ta funkcja działała dla dowolnego obrazka tzn.: 8 bit 16 bit 24 bit?

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TProgowanie::Button17Click(TObject *Sender)
{
        prog5(Image1,Edit5->Text.ToInt());
}

void __fastcall TProgowanie::prog5(TImage *img , int prog)
{
 Graphics::TBitmap *bmp = img->Picture->Bitmap;
 bmp->PixelFormat = pf8bit;

 for(int x = 0; x < bmp->Height; x++)
 {
  RGBQUAD *piksel = (RGBQUAD *) bmp->ScanLine[x];
  for(int y = 0; y < bmp->Width; y++, piksel++)
  {
   int r = piksel->rgbRed;
   int g = piksel->rgbGreen;
   int b = piksel->rgbBlue;
   int z = piksel->rgbReserved;

   if(r > prog) r = 255; else r = 0;
   if(g > prog) g = 255; else g = 0;
   if(b > prog) b = 255; else b = 0;
   if(z > prog) z = 255; else z = 0;

   piksel->rgbRed   = (BYTE)r;
   piksel->rgbGreen = (BYTE)g;
   piksel->rgbBlue  = (BYTE)b;
   piksel->rgbReserved = (BYTE)z;
  }
 }

 Image1->Picture->Assign(bmp);
 Image1->Picture->Bitmap->PixelFormat = pf1bit;
}

Dzięki.
To działa lecz nie wiem czy jest optymalnie? Czy może być lepiej?

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TProgowanie::prog6(TImage *img , int prog)
{
  int x,y,c = 0;    BYTE* LinePtr;
  switch (img->Picture->Bitmap->PixelFormat)
  {
        case 4, 5 : c = 2; break; //pf15bit, pf16bit
        case 6 : c = 3; break; // pf24bit
        case 7 : c = 4; break; // pf32bit
        default : c = 1; break; // pf1bit, pf4bit, pf8bit
  }
  // progowanie
  for (y = 0; y < img->Picture->Bitmap->Height; y++)
  {
        LinePtr = (BYTE*) img->Picture->Bitmap->ScanLine[y];
        for (x = 0; x < c * img->Picture->Bitmap->Width; x++)
        {
          if (LinePtr[x] > prog)
                LinePtr[x] = 255;
          else
                LinePtr[x] = 0;
        }
  }
  img->Refresh();
}

[polymorphism]

Trochę niskopoziomowej optymalizacji

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

size_t byte_width = c * img->Picture->Bitmap->Width;

for (y = 0; y < img->Picture->Bitmap->Height; y++)
{
        BYTE* p1 = (BYTE*) img->Picture->Bitmap->ScanLine[y];
        BYTE* p2 = p1 + byte_width;
       
        while(p1 < p2)
        {
                *p1 = ((prog - *p1) >> 8); // ważne, żeby 'prog' był typu int lub short
                ++p1;
        }
}

[kwgrkwgr]

Mam pytanie o histogram. Czy ta funkcja jest OK jak dla Builder C++ 2010? Czy jest tu coś nie tak? Obecnie działa działa. Robi histogram dla kolorowego i szarego obrazka:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TProgowanie::Hist(TImage *img , int *r, int *g, int *b, int *gray)
{
  int i, j, srednia, Suma;
  TColor color;

        for (i=0; i<256; i++)
        {
                r[i] = 0;
                g[i] = 0;
                b[i] = 0;
                gray[i] = 0;
        }
        for (i=0; i< img->Picture->Width ; i++)
                for (j=1; j<img->Picture->Bitmap->Height; j++)
                {
                        color = img->Canvas->Pixels[i][j];

                        r[GetRValue(color)]++;     // Jeśli kolor wartości są różne
                        g[GetGValue(color)]++;     // Jeśli kolor
                        b[GetBValue(color)]++;     // Jeśli kolor
                }
                for (i=0; i< 256 ; i++)
                {
                        Suma = r[i] + g[i] + b[i] ;
                        if(Suma !=0) srednia = (int)Suma / 3 ; else srednia = 0;
                        gray[i] = srednia ;
                }
}

Chodzi o to że tu pobieram 3 wartości a w nowszym Builderze są 4 bajty.
Dziękuje za sprawdzenie.

[polymorphism]

Jak to w nowszym 4 bajty? Jeśli masz do czynienia z bitmapą 24 bitową, to na kolor przypadać będą zawsze 3 bajty, innej opcji nie ma. Więc jeśli implementujesz algorytm dla bitmap 24 bitowych, zadbaj o to, żeby takie bitmapy Twoja implementacja zawsze dostawała. Wersja środowiska nie ma nic tutaj do rzeczy.

[Cyfrowy Baron]

Chodzi o to że tu pobieram 3 wartości a w nowszym Builderze są 4 bajty.

Chodzi Tobie o składowe RGBQUAD?! Czwarty jest zarezerwowany i powinien wynosić 0 i faktycznie problem z czwartym elementem dotyczy nowszych wersji środowiska. W C++Builder 2006 przeprowadzałem testy zerując czwartą składową i otrzymywałem obrazek pocięty liniami - co czwartą linią. Nie sprawdzałem jeszcze czy zostało to poprawione w C++Builder 2010, ale z ciekawości sprawdzę.

---

Masz tutaj dużo pętli, ale poza tym to kod wydaje się poprawny. Powinieneś pomyśleć nad optymalizacją, by wyeliminować część tych pętli. Na pewno pomogłaby funkcja SkanLine, tak jak to pokazałem w przykładzie.

Jesteś niekonsekwentny:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

for (i=0; i< img->Picture->Width ; i++)
  for (j=1; j<img->Picture->Bitmap->Height; j++)

Raz to jest Picture->Width, a zaraz potem Picture->Bitmap->Height. W obydwu przypadkach powinieneś pobierać rozmiar bitmapy.

[Cyfrowy Baron]

Jak to w nowszym 4 bajty?

W nowszych wersjach struktura RGBQUAD ma 4 elementy, z tym, że czwarty jest zarezerwowany i powinien wynosić 0.

The RGBQUAD structure describes a color consisting of relative intensities of red, green, and blue. typedef struct tagRGBQUAD { BYTE rgbBlue; BYTE rgbGreen; BYTE rgbRed; BYTE rgbReserved; } RGBQUAD; Members rgbBlue Specifies the intensity of blue in the color. rgbGreen Specifies the intensity of green in the color. rgbRed Specifies the intensity of red in the color. rgbReserved Reserved; must be zero.

[polymorphism]

W nowszych wersjach struktura RGBQUAD ma 4 elementy

We wszystkich ma tyle - patrz nazwa . Zresztą z tego co widzę, Pixels zwraca wartość typu TColor, a to typ wyliczeniowy (swoją drogą dziwny pomysł), który ma wielkość int'a, czyli 4 bajty (dla 32bit OSów). Nie widzę tu żadnych RGBQUAD'ów czy RGBTRIPLE. No chyba, że się coś pozmieniało... Chociaż na stronie internetowej też jest TColor.

Jeśli dobrze pamiętam, struktura RGBQUAD jest używana do opisu kolorów palety barw w bitmapach 8 bitowych. Dla bitmap 24 bitowych raczej nie ma zastosowania.

[Cyfrowy Baron]

We wszystkich ma tyle - patrz nazwa .

Nie sprawdzałem, możliwe, że tak jest.

Dla bitmap 24 bitowych raczej nie ma zastosowania.

Jak wspomniałem wcześniej, testowałem tą strukturę i przy wypełnionych tylko trzech elementach i czwartym o wartości 0, otrzymywałem obrazek poprzecinany liniami, co czwarta linia. Testy przeprowadzałem na kolorowej bitmapie w 24 bitach konwertowanej na szarą. Dopiero wypełnienie 4 elementu, tak jak to widać w podanym przeze mnie kodzie, usuwało te linie, dotyczy funkcji ScanLine. Nie wiem więc jak to jest z rezerwacją tego czwartego elementu.

[polymorphism]

W przykładzie masz do czynienia z bitmapą 8 bitową. W takim układzie każdy składnik tej struktury to po prostu kolor kolejnego piksela. Użycie tej struktury w tym przypadku jest niezasadne i mylące. Jedyne zastosowanie to ta struktura miałaby w przypadku bitmap 32 bitowych (RGBA/BGRA - na czwarte pole przypadałby składnik alfa).

[Cyfrowy Baron]

Użycie tej struktury w tym przypadku jest niezasadne i mylące.

W sumie to można by użyć RGBTRIPLE:

typedef struct tagRGBTRIPLE { BYTE rgbtBlue; BYTE rgbtGreen; BYTE rgbtRed; } RGBTRIPLE;

Jeżeli operacje wykonywane są na szarej bitmapie lub monochromatycznej to być może lepiej sprawdziłaby się struktura GRAYCOLOR:

struct GRAYCOLOR { WORD gray; };