example - Cómo manipular imágenes a nivel de píxel en C#

summary example c#

Question

¿Cómo manipulo imágenes a nivel de píxel en C #?

Necesito poder leer / modificar cada píxel de mapa de bits valores RGB por separado.

Una muestra de código sería apreciada.

Answer 1

Si el rendimiento es crítico, se administra otra alternativa a LockBits DirectX.

Consulte la pregunta anterior Desbordamiento de pila Gráficos de representación en C # para obtener más información.

Al igual que Lockbits, deberá usar el modificador de palabra clave / compilador inseguro, pero obtendrá acceso de nivel de píxel de alto rendimiento.

También obtiene una representación de pantalla de mayor rendimiento a través de la función Backbuffering de DirectX, en comparación con el uso de la clase Bitmap normal y el control PictureBox.

Answer 2

Si quieres velocidad, entonces LockBits . Vea aquí un buen tutorial de Bob Powell . Si solo quiere editar algunas, GetPixel / SetPixel debe hacer lo que quiera.

Answer 3

System.Drawing.Bitmap tiene un método público GetPixel (int x, int y) que devuelve una estructura System.Drawing.Color. Esa estructura tiene miembros de byte R, G, B y A, que puedes modificar directamente, y luego volver a llamar a SetPixel (Color) en tu Bitmap.
Desafortunadamente, va a ser relativamente lento, pero es por la forma más fácil de hacerlo en C #. Si trabajas mucho con píxeles individuales y encuentras que el rendimiento es deficiente, y necesitas algo más rápido, puedes usar LockBits ... Sin embargo, es mucho más complicado, ya que necesitas entender la estructura de bits para esa profundidad y tipo de color. , y trabaje con la zancada del mapa de bits y lo que no ... así que si encuentra que es necesario, ¡asegúrese de encontrar un buen tutorial! Hay varios por ahí en la web, googlear "C # LockBits" le dará media docena que vale la pena leer.

Answer 4

Una rutina de código de muestra (la utilizo para una fusión simple y funcionalidad de comparación. Toma dos imágenes y produce una tercera escala de grises que muestra las diferencias entre las dos imágenes como un nivel de tono de escala de grises. Cuanto más oscura es, más dif).

    public static Bitmap Diff(Bitmap src1, Bitmap src2, int x1, int y1, int x2, int y2, int width, int height)
{
    Bitmap diffBM = new Bitmap(width, height, PixelFormat.Format24bppRgb);

    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            //Get Both Colours at the pixel point
            Color col1 = src1.GetPixel(x1 + x, y1 + y);
            Color col2 = src2.GetPixel(x2 + x, y2 + y);

            // Get the difference RGB
            int r = 0, g = 0, b = 0;
            r = Math.Abs(col1.R - col2.R);
            g = Math.Abs(col1.G - col2.G);
            b = Math.Abs(col1.B - col2.B);

            // Invert the difference average
            int dif = 255 - ((r+g+b) / 3);

            // Create new grayscale RGB colour
            Color newcol = Color.FromArgb(dif, dif, dif);

            diffBM.SetPixel(x, y, newcol);

        }
    }

    return diffBM;
}

La publicación de Marc señala LockBits y usa eso para modificar la imagen directamente en la memoria. Sugeriría mirar eso en lugar de lo que he publicado si el rendimiento es una preocupación. Gracias Marc!