c# - arreglo - Cómo convertir una imagen a una matriz de bytes

picturebox to byte array c#

Question

¿Alguien puede sugerir cómo puedo convertir una imagen a una matriz de bytes y viceversa?

Si alguien tiene algunas muestras de código para ayudarme, sería genial.

Estoy desarrollando una aplicación WPF y usando un lector de flujo.

Answer 1

¿Solo desea los píxeles o la imagen completa (incluidos los encabezados) como una matriz de bytes?

Para píxeles: utilice el método CopyPixels en Bitmap. Algo como:

var bitmap = new BitmapImage(uri);

//Pixel array
byte[] pixels = new byte[width * height * 4]; //account for stride if necessary and whether the image is 32 bit, 16 bit etc.

bitmap.CopyPixels(..size, pixels, fullStride, 0); 

Answer 2

Código de muestra para cambiar una imagen en una matriz de bytes

public byte[] ImageToByteArray(System.Drawing.Image imageIn)
{
   using (var ms = new MemoryStream())
   {
      imageIn.Save(ms,imageIn.RawFormat);
      return  ms.ToArray();
   }
}

C # Image a Byte Array y Byte Array a Image Converter Class

Answer 3

Código:

using System.IO;

byte[] img = File.ReadAllBytes(openFileDialog1.FileName);

Answer 4

Este código recupera las primeras 100 filas de la tabla en SQLSERVER 2012 y guarda una imagen por fila como un archivo en el disco local

 public void SavePicture()
    {
        SqlConnection con = new SqlConnection("Data Source=localhost;Integrated security=true;database=databasename");
        SqlDataAdapter da = new SqlDataAdapter("select top 100 [Name] ,[Picture] From tablename", con);
        SqlCommandBuilder MyCB = new SqlCommandBuilder(da);
        DataSet ds = new DataSet("tablename");
        byte[] MyData = new byte[0];
        da.Fill(ds, "tablename");
        DataTable table = ds.Tables["tablename"];
           for (int i = 0; i < table.Rows.Count;i++ )               
               {
                DataRow myRow;
                myRow = ds.Tables["tablename"].Rows[i];
                MyData = (byte[])myRow["Picture"];
                int ArraySize = new int();
                ArraySize = MyData.GetUpperBound(0);
                FileStream fs = new FileStream(@"C:/NewFolder/" + myRow["Name"].ToString() + ".jpg", FileMode.OpenOrCreate, FileAccess.Write);
                fs.Write(MyData, 0, ArraySize);
                fs.Close();
               }

    }

tenga en cuenta que el directorio con el nombre NewFolder debería existir en C: /

Answer 5

Esto es lo que estoy usando actualmente. Algunas de las otras técnicas que he probado han sido no óptimas porque cambiaron la profundidad de bits de los píxeles (24 bits frente a 32 bits) o ignoraron la resolución de la imagen (ppp).

  // ImageConverter object used to convert byte arrays containing JPEG or PNG file images into 
  //  Bitmap objects. This is static and only gets instantiated once.
  private static readonly ImageConverter _imageConverter = new ImageConverter();

Imagen a matriz de bytes:

  /// <summary>
  /// Method to "convert" an Image object into a byte array, formatted in PNG file format, which 
  /// provides lossless compression. This can be used together with the GetImageFromByteArray() 
  /// method to provide a kind of serialization / deserialization. 
  /// </summary>
  /// <param name="theImage">Image object, must be convertable to PNG format</param>
  /// <returns>byte array image of a PNG file containing the image</returns>
  public static byte[] CopyImageToByteArray(Image theImage)
  {
     using (MemoryStream memoryStream = new MemoryStream())
     {
        theImage.Save(memoryStream, ImageFormat.Png);
        return memoryStream.ToArray();
     }
  }

Conjunto de bytes a la imagen:

  /// <summary>
  /// Method that uses the ImageConverter object in .Net Framework to convert a byte array, 
  /// presumably containing a JPEG or PNG file image, into a Bitmap object, which can also be 
  /// used as an Image object.
  /// </summary>
  /// <param name="byteArray">byte array containing JPEG or PNG file image or similar</param>
  /// <returns>Bitmap object if it works, else exception is thrown</returns>
  public static Bitmap GetImageFromByteArray(byte[] byteArray)
  {
     Bitmap bm = (Bitmap)_imageConverter.ConvertFrom(byteArray);

     if (bm != null && (bm.HorizontalResolution != (int)bm.HorizontalResolution ||
                        bm.VerticalResolution != (int)bm.VerticalResolution))
     {
        // Correct a strange glitch that has been observed in the test program when converting 
        //  from a PNG file image created by CopyImageToByteArray() - the dpi value "drifts" 
        //  slightly away from the nominal integer value
        bm.SetResolution((int)(bm.HorizontalResolution + 0.5f), 
                         (int)(bm.VerticalResolution + 0.5f));
     }

     return bm;
  }

Editar: para obtener la imagen de un archivo jpg o png, debe leer el archivo en una matriz de bytes usando File.ReadAllBytes ():

 Bitmap newBitmap = GetImageFromByteArray(File.ReadAllBytes(fileName));

Esto evita problemas relacionados con el mapa de bits que quiere que su flujo de origen se mantenga abierto, y algunas soluciones alternativas sugeridas para ese problema que hacen que el archivo de origen se mantenga bloqueado.

Answer 6

Otra forma de obtener una matriz Byte desde la ruta de la imagen es

byte[] imgdata = System.IO.File.ReadAllBytes(HttpContext.Current.Server.MapPath(path));

Answer 7

Para convertir un objeto de imagen en byte[] , puede hacer lo siguiente:

public static byte[] converterDemo(Image x)
{
    ImageConverter _imageConverter = new ImageConverter();
    byte[] xByte = (byte[])_imageConverter.ConvertTo(x, typeof(byte[]));
    return xByte;
}

Answer 8

Puede usar el método File.ReadAllBytes() para leer cualquier archivo en una matriz de bytes. Para escribir una matriz de bytes en un archivo, simplemente use el método File.WriteAllBytes() .

Espero que esto ayude.

Puede encontrar más información y código de muestra here .

Answer 9

Si no hace referencia a imageBytes para transportar bytes en la secuencia, el método no devolverá nada. Asegúrese de hacer referencia a imageBytes = m.ToArray ();

    public static byte[] SerializeImage() {
        MemoryStream m;
        string PicPath = pathToImage";

        byte[] imageBytes;
        using (Image image = Image.FromFile(PicPath)) {

            using ( m = new MemoryStream()) {

                image.Save(m, image.RawFormat);
                imageBytes = new byte[m.Length];
               //Very Important    
               imageBytes = m.ToArray();

            }//end using
        }//end using

        return imageBytes;
    }//SerializeImage

Answer 10

prueba esto:

public byte[] imageToByteArray(System.Drawing.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;
}