Redimensionner l'image qui est placée dans la matrice d'octet []

Je n'ai aucune implémentation définitive pour vous, mais je l'aborderais de cette façon:

Vous pouvez stocker 51200 valeurs (non comprimé). Et vous connaissez le ratio de l'original: Calculez les dimensions avec le rapport et la taille de la nouvelle image: xxx

pour le rééchantillonnage des valeurs, je voudrais utiliser un noyau de filtre: http://fr.wikipedia.org/wiki/lanczos_Resampling

Haven 't l'a encore utilisé, mais semble prometteur.

sauf si vous voulez entrer dans des mathématiques graves, vous devez charger votre réseau d'octets dans un flux de mémoire, charger une image à partir de ce flux de mémoire et utiliser les fonctions GDI intégrées dans l'espace de noms System.Drawing.

Faire une échelle de 25% ou 50% est facile. Au-delà de cela, vous devez commencer à faire l'interpolation et à différencer pour que tout ressemblait à la moitié de la manipulation des données binaires. Vous serez plusieurs jours avant de pouvoir correspondre à ce qui est déjà disponible dans GDI. xxx

BTW - Si vous devez vraiment comprendre votre type d'image source, voir: < un href = "https://stackoverflow.com/questions/8349693/how-to-check-if-a-byte-array-is-a-valid-image"> Comment vérifier si un tableau d'octet est une image valide

Je suis utilisé ceci ....

    public static byte[] ImagenToByteArray(System.Drawing.Image imageIn)
    {
        MemoryStream ms = new MemoryStream();
        imageIn.Save(ms, System.Drawing.Imaging.ImageFormat.Gif);
        return ms.ToArray();
    }

OK, alors après quelques expériences, j'ai quelque chose comme ça: XXX

a une autre idée? Malheureusement image.GetthumbnailImage () causait des images très sales.

Supposons que vous lisiez un fichier à partir d'un fichier de lecteur

p>

 FileStream streamObj = System.IO.File.OpenRead(@"C:\Files\Photo.jpg");

Byte[] newImage=UploadFoto(streamObj); 
 
  public static Byte[] UploadFoto(FileStream fileUpload)
        {
            Byte[] imgByte = null;
            imgByte = lnkUpload(fileUpload);
            return imgByte;
        }
        
        
         private static Byte[] lnkUpload(FileStream img)
        {
            byte[] resizedImage;
            using (Image orginalImage = Image.FromStream(img))
            {
                ImageFormat orginalImageFormat = orginalImage.RawFormat;
                int orginalImageWidth = orginalImage.Width;
                int orginalImageHeight = orginalImage.Height;
                int resizedImageWidth = 60; // Type here the width you want
                int resizedImageHeight = Convert.ToInt32(resizedImageWidth * orginalImageHeight / orginalImageWidth);
                using (Bitmap bitmapResized = new Bitmap(orginalImage, resizedImageWidth, resizedImageHeight))
                {
                    using (MemoryStream streamResized = new MemoryStream())
                    {
                        bitmapResized.Save(streamResized, orginalImageFormat);
                        resizedImage = streamResized.ToArray();
                    }
                }
            }
            return resizedImage;
        }

La solution pour .NET CORE 3.1 et plus:

1. Installer System.Drawing.common code> Nuget: Li> ol> xxx pré>
   2. Le code pour modifier la taille de l'image d'un tableau d'octets: LI> ol> xxx pré>

      update: strong> L'approche ci-dessus ne peut pas fonctionner pour Linux. La solution universelle est donc la suivante: p>

      1. Installez SIXLABORS.IMESSHARP CODE> Nuget: Li> ol> xxx pré>
         2. Écrivez le code suivant: LI> OL>

            private static byte[] ReduceImage(byte[] bytes)
            {
                using var memoryStream = new MemoryStream(bytes);
                using var image = Image.Load(memoryStream);
                image.Mutate(x => x.Resize(ReducedWidth, ReducedHeight));
                using var outputStream = new MemoryStream();
                image.Save(outputStream, new PngEncoder() /*or another encoder*/); 
                return outputStream.ToArray();
            }