сглаживание изображения

int Lowpass(BYTE Image[][256], int x, int y)
{
        int Mask[3][3] = {{1, 1, 1,}, {1, 1, 1}, {1, 1, 1}};
        int i, j, sum=0;
 
        for (j=-1; j<=1; j++)
                for (i=-1; i<=1; i++)
                      sum += Image[x+i][y+j]*Mask[i+1][j+1];
        return INT(sum/9.0);
}
 
void __fastcall TForm1::Button8Click(TObject *Sender)
{
        // Код инициализации не показан.
 
        // Вычисляем низкочастотное изображение.
        for (y=1; y<=254; y++)
                for (x=1; x<=254; x++)
                        Output[x][y] = Lowpass(ImageData, x, y);
 
        // Копирование обратно в изображение не показано.
}

bool Smooth (Graphics::TBitmap *BmpIn, Graphics::TBitmap *BmpOut)
{
    int x, y;
    int h_In = BmpIn->Height;
    int w_In = BmpIn->Width;
    BYTE *line_ptr;
    BYTE ***in = NULL;
 
    try
    {
        BmpIn->PixelFormat = pf24bit;
        if (BmpOut != BmpIn)
        {
            BmpOut->PixelFormat = pf24bit;
            BmpOut->Width = BmpIn->Width;
            BmpOut->Height = BmpIn->Height;
        }
 
        // выделение памяти
        in = new BYTE **[3];
        for (int i=0; i<3; i++)
        {
            in[i] = new BYTE *[w_In];
            for (int j=0; j<w_In; j++)
            {
                in[i][j] = new BYTE[h_In];
            }
        }
 
        // копирование изображения из BmpIn в массив in
        for (y=0; y<h_In; y++)
        {
            line_ptr = (BYTE *)BmpIn->ScanLine[y];
            for (x=0; x<w_In; x++)
            {
                in[0][x][y] = line_ptr[x*3];   // красный канал
                in[1][x][y] = line_ptr[x*3+1]; // зелёный канал
                in[2][x][y] = line_ptr[x*3+2]; // синий канал
            }
        }
 
        for (y=1; y<h_In-1; y++)
        {
            line_ptr = (BYTE *)BmpOut->ScanLine[y];
            for (x=1; x<w_In-1; x++)
            {
                float sum1=0, sum2=0, sum3=0;
                for (int j=-1; j<=1; j++)
                {
                    for (int i=-1; i<=1; i++)
                    {
                        sum1 += in[0][x+i][y+j];
                        sum2 += in[1][x+i][y+j];
                        sum3 += in[2][x+i][y+j];
                    }
                }
                line_ptr[x*3] = (BYTE)(sum1/9);
                line_ptr[x*3+1] = (BYTE)(sum2/9);
                line_ptr[x*3+2] = (BYTE)(sum3/9);
            }
        }
 
        // освобождение памяти
        for (int i=0; i<3; i++)
        {
            for (int j=0; j<w_In; j++)
            {
                delete[] in[i][j];
            }
            delete[] in[i];
        }
        delete[] in;
    }
    catch (...)
    {
        return false;
    }
    return true;
}
//---------------------------------------------------------------------------

    AnsiString FileName = "c:\\defender.jpg";
    AnsiString ext = AnsiLowerCase (ExtractFileExt (FileName).Delete(1,1));
 
    Img_In->Picture->LoadFromFile (FileName);
    Img_In->Refresh();
 
    std::auto_ptr <Graphics::TPicture> picture (new Graphics::TPicture);
 
    if (ext == "jpeg" || ext == "jpg")
    {
        std::auto_ptr <TJPEGImage> jpg (new TJPEGImage);
        jpg->Assign (picture.get());
        jpg->DIBNeeded();
        picture->Bitmap->Assign (jpg.get());
    }
    else
    {
        picture->Assign (Img_In->Picture);
    }
 
    Smooth (picture->Bitmap, Img_Out->Picture->Bitmap);
    Img_Out->Refresh();

int Mask[3][3] = {{1, 1, 1,}, {1, 1, 1}, {1, 1, 1}};
 
.....
    sum1 += in[0][x+i][y+j]*Mask[i+1][j+1];;
    sum2 += in[1][x+i][y+j]*Mask[i+1][j+1];
    sum3 += in[2][x+i][y+j]*Mask[i+1][j+1];