erozja nie rozumiem pętli

Witam, próbuje rozgryźć jak działa erozja na obrazie binarnym mając taki kod pomoglby mi ktos go zrozumiec? Wyzej w kodzie k zostalo zadeklarowane jako k=3

void MyWindow::erozja()
{
    bool flaga = false;

    for(int i=0; i<szer; i++)
    {
        for(int j=0; j<wys; j++)
        {
            for(int x=i-(k/2); x<=i+(k/2); x++)
            {
                for(int y=j-(k/2); y<=j+(k/2); y++)
                {
                    if(porownajkolor(x,y,0,0,0)) flaga=true; 
                }
            }

            if(flaga)
            {
                putpixel(i,j,0,0,0);
                flaga=false;
            }
        }
    }

    if(tryb==0)
    {
        *img=img4->copy(0,0,szer,wys);
    } else {
        *img3=img2->copy(0,0,szer,wys);
    }
    update();
}

A czego nie rozumiesz?

Uczenie się programowania od autora tego kodu nie jest najlepszym pomysłem, bo on sam się dopiero uczy.
Na dodatek załączyłeś niekompletny kod (nie wiadomo co robią: porownajkolor, putpixel), więc trudno wytłumaczyć co to dokładnie robi.

Na dodatek ponieważ są tam ujemne indeksy, to są poważne podstawy, by podejrzewać, że ten kod ma Undefined behavior.

wrzucam funkcje putpixel oraz porownajjakolor, chodzi mi po prostu o zasade działania dlaczego zostaly uzyte takie wartosci np w petli

 for(int x=i-(k/2); x<=i+(k/2); x++)
            {
                for(int y=j-(k/2); y<=j+(k/2); y++)
                {
                    if(porownajkolor(x,y,0,0,0)) flaga=true; 
                }
            }

bool MyWindow::porownajkolor(int x, int y, int r, int g, int b)
{
    unsigned char *ptr;
    // dzięki zmiennej tryb przechodzimy do obrazka lub sami rysujemy
    if(tryb==0)
    {
        ptr = img->bits();
    } else {
        ptr = img3->bits();
    }
    // sprawdzamy piksele do okola jednego piksela i jeśli się zgadza kolor to zwaracamy true jeśli nie false
    if((x>=0)&&(y>=0)&&(x<szer)&&(y<wys))
    {
        if(ptr[szer*4*y + 4*x]==b && ptr[szer*4*y + 4*x + 1]==g && ptr[szer*4*y + 4*x + 2]==r)
            return true;
        else
            return false;
    }
    else return false;
}

void MyWindow::putpixel(int x, int y, int r, int g, int b)
{
    unsigned char *ptr;
    if(tryb==0)
    {
        ptr = img4->bits();
    } else {
        ptr = img2->bits();
    }
    x -= poczX;
    y -= poczY;
    if ((x>=0)&&(y>=0)&&(x<szer)&&(y<wys))
    {
        ptr[szer*4*y + 4*x]     = uchar(r);
        ptr[szer*4*y + 4*x + 1] = uchar(g);
        ptr[szer*4*y + 4*x + 2] = uchar(b);
    }

}

To compute the erosion of a binary input image by this structuring element, we consider each of the foreground pixels in the input image in turn. For each foreground pixel (which we will call the input pixel) we superimpose the structuring element on top of the input image so that the origin of the structuring element coincides with the input pixel coordinates. If for every pixel in the structuring element, the corresponding pixel in the image underneath is a foreground pixel, then the input pixel is left as it is. If any of the corresponding pixels in the image are background, however, the input pixel is also set to background value.

Erozja