Conversión de matriz de bytes a imagen

Quiero convertir una matriz de bytes en una imagen.

Este es el código de mi base de datos de donde obtengo la matriz de bytes:

public void Get_Finger_print()
{
    try
    {
        using (SqlConnection thisConnection = new SqlConnection(@"Data Source=" + System.Environment.MachineName + "\\SQLEXPRESS;Initial Catalog=Image_Scanning;Integrated Security=SSPI "))
        {
            thisConnection.Open();
            string query = "select pic from Image_tbl";// where Name='" + name + "'";
            SqlCommand cmd = new SqlCommand(query, thisConnection);
            byte[] image =(byte[]) cmd.ExecuteScalar();
            Image newImage = byteArrayToImage(image);
            Picture.Image = newImage;
            //return image;
        }
    }
    catch (Exception) { }
    //return null;
}

Mi código de conversión:

public Image byteArrayToImage(byte[] byteArrayIn)
{
    try
    {
        MemoryStream ms = new MemoryStream(byteArrayIn,0,byteArrayIn.Length);
        ms.Write(byteArrayIn, 0, byteArrayIn.Length);
        returnImage = Image.FromStream(ms,true);//Exception occurs here
    }
    catch { }
    return returnImage;
}

Cuando llego a la línea con un comentario, ocurre la siguiente excepción: Parameter is not valid.

¿Cómo puedo solucionar lo que esté causando esta excepción?

Está escribiendo en su flujo de memoria dos veces, y tampoco está desechando el flujo después de su uso. También le solicita al decodificador de imágenes que aplique la corrección de color incorporada.

Prueba esto en su lugar:

using (var ms = new MemoryStream(byteArrayIn))
{
    return Image.FromStream(ms);
}

Tal vez me esté perdiendo algo, pero para mí este de una sola línea funciona bien con una matriz de bytes que contiene una imagen de un archivo JPEG.

Image x = (Bitmap)((new ImageConverter()).ConvertFrom(jpegByteArray));

EDITAR:

Consulte aquí para obtener una versión actualizada de esta respuesta: Cómo convertir una imagen en una matriz de bytes

public Image byteArrayToImage(byte[] bytesArr)
{
    using (MemoryStream memstr = new MemoryStream(bytesArr))
    {
        Image img = Image.FromStream(memstr);
        return img;
    }
}

Me gustaría señalar que hay un error en la solución proporcionada por @ isaias-b.

Esa solución supone que stridees igual a la longitud de la fila. Pero no siempre es cierto. Debido a las alineaciones de memoria realizadas por GDI, el paso puede ser mayor que la longitud de la fila. Esto debe tenerse en cuenta. De lo contrario, se generará una imagen desplazada no válida. Se ignorarán los bytes de relleno en cada fila.

La zancada es el ancho de una sola fila de píxeles (una línea de exploración), redondeada a un límite de cuatro bytes.

Código fijo:

using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

public static class ImageExtensions
{
    public static Image ImageFromRawBgraArray(this byte[] arr, int width, int height, PixelFormat pixelFormat)
    {
        var output = new Bitmap(width, height, pixelFormat);
        var rect = new Rectangle(0, 0, width, height);
        var bmpData = output.LockBits(rect, ImageLockMode.ReadWrite, output.PixelFormat);

        // Row-by-row copy
        var arrRowLength = width * Image.GetPixelFormatSize(output.PixelFormat) / 8;
        var ptr = bmpData.Scan0;
        for (var i = 0; i < height; i++)
        {
            Marshal.Copy(arr, i * arrRowLength, ptr, arrRowLength);
            ptr += bmpData.Stride;
        }

        output.UnlockBits(bmpData);
        return output;
    }
}

Para ilustrar a qué puede conducir, generemos una PixelFormat.Format24bppRgbimagen de degradado de 101x101:

var width = 101;
var height = 101;
var gradient = new byte[width * height * 3 /* bytes per pixel */];
for (int i = 0, pixel = 0; i < gradient.Length; i++, pixel = i / 3)
{
    var x = pixel % height;
    var y = (pixel - x) / width;
    gradient[i] = (byte)((x / (double)(width - 1) + y / (double)(height - 1)) / 2d * 255);
}

Si copiamos la matriz completa como está en la dirección señalada bmpData.Scan0, obtendremos la siguiente imagen. Cambio de imagen porque parte de la imagen se escribió en bytes de relleno, eso se ignoró. También es por eso que la última fila está incompleta:

Pero si copiamos el puntero de destino de cambio fila por fila por bmpData.Stridevalor, se generarán imágenes válidas:

Stride también puede ser negativo:

Si la zancada es positiva, el mapa de bits es de arriba hacia abajo. Si la zancada es negativa, el mapa de bits es de abajo hacia arriba.

Pero no trabajé con tales imágenes y esto está más allá de mi nota.

Respuesta relacionada: C #: búfer RGB de mapa de bits diferente de C ++

Todas las respuestas presentadas asumen que la matriz de bytes contiene datos en una representación de formato de archivo conocido, como: gif, png o jpg. Pero recientemente tuve un problema al intentar convertir byte[]correos electrónicos, que contienen información BGRA linealizada, de manera eficiente en Imageobjetos. El siguiente código lo resuelve usando un Bitmapobjeto.

using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
public static class Extensions
{
    public static Image ImageFromRawBgraArray(
        this byte[] arr, int width, int height)
    {
        var output = new Bitmap(width, height);
        var rect = new Rectangle(0, 0, width, height);
        var bmpData = output.LockBits(rect, 
            ImageLockMode.ReadWrite, output.PixelFormat);
        var ptr = bmpData.Scan0;
        Marshal.Copy(arr, 0, ptr, arr.Length);
        output.UnlockBits(bmpData);
        return output;
    }
}

Esta es una pequeña variación de una solución que se publicó en este sitio .

hay un enfoque simple como el siguiente, puede usar el FromStreammétodo de una imagen para hacer el truco, solo recuerde usarlo System.Drawing;

// using image object not file 
public byte[] imageToByteArray(Image imageIn)
{
    MemoryStream ms = new MemoryStream();
    imageIn.Save(ms,System.Drawing.Imaging.ImageFormat.Gif);
    return ms.ToArray();
}

public Image byteArrayToImage(byte[] byteArrayIn)
{
    MemoryStream ms = new MemoryStream(byteArrayIn);
    Image returnImage = Image.FromStream(ms);
    return returnImage;
}

probar (ACTUALIZAR)

MemoryStream ms = new MemoryStream(byteArrayIn,0,byteArrayIn.Length);
ms.Position = 0; // this is important
returnImage = Image.FromStream(ms,true);

No ha declarado returnImage como ningún tipo de variable :)

Esto debería ayudar:

public Image byteArrayToImage(byte[] byteArrayIn)
{
    try
    {
        MemoryStream ms = new MemoryStream(byteArrayIn,0,byteArrayIn.Length);
        ms.Write(byteArrayIn, 0, byteArrayIn.Length);
        Image returnImage = Image.FromStream(ms,true);
    }
    catch { }
    return returnImage;
}

Esto está inspirado en la respuesta de Holstebroe, más los comentarios aquí: Obtener un objeto Imagen de una matriz de bytes

Bitmap newBitmap;
using (MemoryStream memoryStream = new MemoryStream(byteArrayIn))
    using (Image newImage = Image.FromStream(memoryStream))
        newBitmap = new Bitmap(newImage);
return newBitmap;

Un trazador de líneas:

Image bmp = (Bitmap)((new ImageConverter()).ConvertFrom(imageBytes));

La mayoría de las veces, cuando esto sucede, son datos incorrectos en la columna SQL. Esta es la forma correcta de insertar en una columna de imagen:

INSERT INTO [TableX] (ImgColumn) VALUES (
(SELECT * FROM OPENROWSET(BULK N'C:\....\Picture 010.png', SINGLE_BLOB) as tempimg))

La mayoría de la gente lo hace incorrectamente de esta manera:

INSERT INTO [TableX] (ImgColumn) VALUES ('C:\....\Picture 010.png'))

Primero instale este paquete:

Paquete de instalación SixLabors.ImageSharp -Version 1.0.0-beta0007

[SixLabors.ImageSharp] [1] [1]: https://www.nuget.org/packages/SixLabors.ImageSharp

Luego use el siguiente código para Cast Byte Array To Image:

Image<Rgba32> image = Image.Load(byteArray); 

Para obtener ImageFormat, utilice el siguiente código:

IImageFormat format = Image.DetectFormat(byteArray);

Para el uso de imagen mutada debajo del código:

image.Mutate(x => x.Resize(new Size(1280, 960)));