web-dev-qa-db-fra.com

Comment convertir une image en tableau d'octets

Quelqu'un peut-il suggérer comment je peux convertir une image en tableau d'octets et vice versa?

Si quelqu'un a des exemples de code pour m'aider, ce serait formidable.

Je développe une application WPF et utilise un lecteur de flux.

c#wpf
94
Shashank

Exemple de code pour changer une image en tableau d'octets

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

Image C # en tableau d'octets et Tableau d'octets en classe de convertisseur d'image

128
Pranay Rana

Pour convertir un objet Image en byte[], vous pouvez procéder comme suit:

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

Une autre façon d’obtenir un tableau Byte à partir du chemin d’image est la suivante:

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

essaye ça:

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;
}
16
anishMarokey

Vous pouvez utiliser la méthode File.ReadAllBytes() pour lire n'importe quel fichier dans un tableau d'octets. Pour écrire un tableau d'octets dans un fichier, utilisez simplement la méthode File.WriteAllBytes().

J'espère que cela t'aides.

Vous pouvez trouver plus d'informations et un exemple de code ici .

14
Shekhar

Voici ce que j'utilise actuellement. Certaines des autres techniques que j'ai essayées ont été non optimales car elles ont modifié la profondeur de bits des pixels (24 bits par rapport à 32 bits) ou ignoré la résolution de l'image (dpi).

  // 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();

Image à tableau d'octets:

  /// <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();
     }
  }

Tableau d'octets à l'image:

  /// <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;
  }

Edit: pour obtenir l'image à partir d'un fichier jpg ou png, vous devez lire le fichier dans un tableau d'octets à l'aide de File.ReadAllBytes ():

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

Cela évite les problèmes liés au fait que Bitmap souhaite garder son flux source ouvert, ainsi que certaines solutions suggérées pour résoudre ce problème, qui entraînent le verrouillage du fichier source.

13
RenniePet

Voulez-vous seulement les pixels ou toute l'image (y compris les en-têtes) sous forme de tableau d'octets?

Pour les pixels: utilisez la méthode CopyPixels sur Bitmap. Quelque chose comme:

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);
5
Lasse Espeholt

Si vous ne faites pas référence à imageBytes pour transporter des octets dans le flux, la méthode ne renverra rien. Assurez-vous de référencer 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
3
Ernest

Code:

using System.IO;

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

Ceci est un code pour convertir l'image de tout type (par exemple, PNG, JPG, JPEG) en tableau d'octets

   public static byte[] imageConversion(string imageName){            


        //Initialize a file stream to read the image file
        FileStream fs = new FileStream(imageName, FileMode.Open, FileAccess.Read);

        //Initialize a byte array with size of stream
        byte[] imgByteArr = new byte[fs.Length];

        //Read data from the file stream and put into the byte array
        fs.Read(imgByteArr, 0, Convert.ToInt32(fs.Length));

        //Close a file stream
        fs.Close();

        return imageByteArr
    }
0
Sureya Pragaash