Aplicar una máscara a una imagen

[kayss]

Hola!

Alguno sabéis de una forma rápida de aplicar una máscara a una imagen en mapa de bits.

Yo primero creo la máscara (matriz nxn), recorro pixel a pixel la imagen, sitúo la máscara y recorro la máscara posición por posición para dicho pixel, y así con todos los demás pixels de la imagen.

Como os podeis imaginar esto tarda mucho en ejecutarse para una imagen de una resolución media.

Espero algunos sepais algún método más rápido


Saludos

[ivancp]

Puedes utilizar la funcion bitblt con el parametro SRC_AND, que realiza la operacion booleana AND con cada pixel.

Un ejemplo de emplear mascaras:
http://www.codeproject.com/bitmap/transbitmapmask.asp

[kayss]

Hola,

Al final he conseguido reducir a la mitad el tiempo de procesamiento a la mitad con el siguiente código. Lo que hago es trabajar a nivel de byte, en lugar de a nivel de pixel, que es más rápido, aunque sigue tardando bastante. Espero que a vosotros se os ocurra otra idea o una mejora del código.

Código: Seleccionar todo

Bitmap^ AplicarMascara2(System::Drawing::Bitmap ^Imagen, cli::array<double>^ Mascara, Int32 Tamanio){
    this->ImagenFiltrada=gcnew System::Drawing::Bitmap (Imagen->Width, Imagen->Height);
    Int32 i, j, k, q, IncX, IncY, X, Y, ValorPixel, PosVectorRGB, Sumatorio;
    Color color;
    Int32 Cte1=Tamanio/2;

    // formato de pixel
    PixelFormat pxf = PixelFormat::Format24bppRgb;

    // Bloqueamos los pixels de la imagen original y la filtrada
    Rectangle rect = System::Drawing::Rectangle(0, 0, Imagen->Width, Imagen->Height);
    BitmapData ^bmpDatosOriginal = Imagen->LockBits(rect, ImageLockMode::ReadWrite, pxf);
    BitmapData ^bmpDatosFiltrada = ImagenFiltrada->LockBits(rect, ImageLockMode::ReadWrite, pxf);

    // Obtenemos la direcciones de comienzo
    IntPtr ptrOriginal = bmpDatosOriginal->Scan0;
    IntPtr ptrFiltrada = bmpDatosFiltrada->Scan0;

    // Declaramos los arrays para almacenar los bytes de los bitmaps
    Int32 numBytes = Imagen->Width * Imagen->Height * 3;
    array<Byte> ^valoresRGBOriginal = gcnew array<Byte>(numBytes);
    array<Byte> ^valoresRGBFiltrada = gcnew array<Byte>(numBytes);

    // Copiamos los valores RGB a los arrays
    Marshal::Copy(ptrOriginal, valoresRGBOriginal, 0, numBytes);
    Marshal::Copy(ptrFiltrada, valoresRGBFiltrada, 0, numBytes);

    // Recorremos la imagen
    for(i=0; i<Imagen->Width; i++){
        for (j=0; j<Imagen->Height; j++){
           
            IncY=Cte1;
            Sumatorio=0;

            // Recorremos la máscara
            for (k=0; k<Tamanio; k++){
               
                Y=j+IncY;
                IncX=Cte1;

                for (q=0; q<Tamanio; q++){
                    X=i+IncX;
                    if ((X>=0&&X<Imagen->Width) && (Y>=0&&Y<Imagen->Height)) Sumatorio=Sumatorio + (Int32)(Mascara[(Cte1+IncX)*3 + (Cte1+IncY)])*(valoresRGBOriginal[(Y*Imagen->Width+X)*3]);

                    IncX--;
                }
                IncY--;
            }
           
            // El valor del pixel será el valor del sumatorio obtenido
            if (Sumatorio>0)ValorPixel=Sumatorio%255;
            else ValorPixel=0;
            PosVectorRGB=(j*Imagen->Width+i)*3;
            valoresRGBFiltrada[PosVectorRGB]=ValorPixel;
            valoresRGBFiltrada[PosVectorRGB+1]=ValorPixel;
            valoresRGBFiltrada[PosVectorRGB+2]=ValorPixel;
        }
    }

    // Copiamos de nuevo los valores del array al bitmap
    Marshal::Copy(valoresRGBFiltrada, 0, ptrFiltrada, numBytes);

    // Desbloqueamos los bites
    ImagenFiltrada->UnlockBits(bmpDatosFiltrada);
    Imagen->UnlockBits(bmpDatosOriginal);

    return ImagenFiltrada;

}

Un saludo