Come utilizzare i valori del colore calcolata con ColorMatrix?

Question

Sto cambiando i valori di colore di ogni pixel in un'immagine sulla base di un calcolo. Il problema è che questo richiede più di 5 secondi sulla mia macchina con un'immagine di 1000x1333 e sto cercando un modo per ottimizzare che sia molto più veloce.

Credo ColorMatrix può essere un'opzione, ma sto avendo un momento difficile capire come vorrei avere un insieme di pixel valori RGB, l'uso che per calcolare e quindi impostare il nuovo valore del pixel. Posso vedere come questo può essere fatto se ero appena modificanti (moltiplicando, sottraendo, ecc) il valore originale con ColorMatrix, ma ora come posso utilizzare i pixel restituiti valore da utilizzare per calcolare e nuovo valore.

Ad esempio:

Sub DarkenPicture()
    Dim clrTestFolderPath = "C:\Users\Me\Desktop\ColorTest\"
    Dim originalPicture = "original.jpg"
    Dim Luminance As Single
    Dim bitmapOriginal As Bitmap = Image.FromFile(clrTestFolderPath + originalPicture)
    Dim Clr As Color
    Dim newR As Byte
    Dim newG As Byte
    Dim newB As Byte
    For x = 0 To bitmapOriginal.Width - 1
        For y = 0 To bitmapOriginal.Height - 1
            Clr = bitmapOriginal.GetPixel(x, y)
            Luminance = ((0.21 * (Clr.R) + (0.72 * (Clr.G)) + (0.07 * (Clr.B))/ 255
            newR = Clr.R * Luminance
            newG = Clr.G * Luminance
            newB = Clr.B * Luminance
            bitmapOriginal.SetPixel(x, y, Color.FromArgb(newR, newG, newB))
        Next
    Next
    bitmapOriginal.Save(clrTestFolderPath + "colorized.jpg", ImageFormat.Jpeg)
End Sub

Il valore Luminance è quello calcolato. So di poter impostare di ColorMatrix M00, M11, M22 a 0, 0, 0 rispettivamente e quindi inserire un nuovo valore in M40, M41, M42, ma il nuovo valore viene calcolato sulla base di una moltiplicazione valore e l'aggiunta di componenti che del pixel (((0.21 * (Clr.R) + (0.72 * (Clr.G)) + (0.07 * (Clr.B)) e il risultato di questo - Luminance -. viene moltiplicato per il componente di colore)

Questo è anche possibile con ColorMatrix?

Answer 1

No. Effettuando uno dei componenti di colore è moltiplicata con se stesso o qualsiasi altro componente non è possibile con un ColorMatrix. Ony moltiplicano i componenti con costanti e quindi è possibile aggiungere le parti insieme.

Ma che cosa si possono fare è scrivere questo in C # e sull'uso .LockBits invece di GetPixel / SetPixel. Questo sarebbe ancora più veloce che quello che si potrebbe ottenere con un ColorMatrix.

Aggiorna : alcuni esempi di codice:

    private static void myVerySpecialSepia(
        IntPtr source,
        IntPtr destination,
        int height,
        int width,
        int sourceStride,
        int destinationStride,
        int sourceBytesPerPixel,
        int destinationBytesPerPixel )
    {
        unsafe
        {
            for ( int y = 0 ; y < height ; y++ )
            {
                byte* pOrig = (byte*)source.ToPointer() + sourceStride * y;
                byte* pDest = (byte*)destination.ToPointer() + destinationStride * y;
                for ( int x = width ; x > 0 ; x-- )
                {
                    float b = pOrig[0];
                    float g = pOrig[1];
                    float r = pOrig[2];
                    float b2 = b * b;
                    float g2 = g * g;
                    float r2 = r * r;
                    pDest[0] = (byte)(
                        b * 0.400367618f + b2 * 0.00011502471f +
                        g * (-0.0337239578f) + g2 * 0.00056673412f +
                        r * 0.221445322f + r2 * 0.0008506606f +
                        6.2766808485f);
                    pDest[1] = (byte)(
                        b * 0.493460029f + b2 * (-0.00023297003f) +
                        g * (-0.008577178f) + g2 * 0.00031247039f +
                        r * 0.5043012 + r2 * (-0.00006892065f) +
                        0.2746957206f);
                    pDest[2] = (byte)(
                        b * 0.617727f + b2 * (-0.00070876251f) +
                        g * 0.00271902746f + g2 * 0.00007401942f +
                        r * 0.6954346f + r2 * (-0.00065937551f) +
                        0.116103285f);
                    pOrig += sourceBytesPerPixel;
                    pDest += destinationBytesPerPixel;
                }
            }
        }
    }