Chargement et traitement de bitmaps

Applies to Windows and Windows Phone

Voici du code qui autorise l’utilisateur à sélectionner une image à l’aide d’un contrôle FilePicker, puis qui la charge et qui la traite.

Windows 8 propose des contrôles FilePicker permettant aux utilisateurs de sélectionner rapidement des fichiers tels que des images.

Remarque  Les applications écrites pour Windows Phone 8.1 doivent utiliser PickSingleFileAndContinue à la place de PickSingleFileAsync. L’utilisation de cette API nécessite des étapes supplémentaires (voir Comment permettre à votre application Windows Phone de continuer à s’exécuter après l’appel d’un sélecteur de fichiers (applications du Windows Phone Store en C#/VB/C++ et XAML)).

Dans ce court exemple de code C#, l’utilisateur peut utiliser le contrôle FilePicker pour sélectionner un fichier image, qui s’affichera ensuite dans notre application. La seule supposition est que votre application possède déjà un contrôle <Image> XAML et que vous l’avez nommé myImage. Voici le code :


async private void LoadImage()
        {
            // Load an image

             Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker();

                 openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary;
                 openPicker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail;
                 
                 // Filter to include a sample subset of file types.
                 openPicker.FileTypeFilter.Clear();
                 openPicker.FileTypeFilter.Add(".bmp");
                 openPicker.FileTypeFilter.Add(".png");
                 openPicker.FileTypeFilter.Add(".jpeg");
                 openPicker.FileTypeFilter.Add(".jpg");

                // Open the file picker.
                Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync();

                // file is null if user cancels the file picker.
                if (file != null)
                {
                    // Open a stream for the selected file.
                    Windows.Storage.Streams.IRandomAccessStream fileStream =
                        await file.OpenAsync(Windows.Storage.FileAccessMode.Read);

                    // Set the image source to the selected bitmap.
                    Windows.UI.Xaml.Media.Imaging.BitmapImage bitmapImage =
                        new Windows.UI.Xaml.Media.Imaging.BitmapImage();

                    bitmapImage.SetSource(fileStream);
                    myImage.Source = bitmapImage;
                    this.DataContext = file;

                }
            }

Remarque  Comme ce code utilise le mot clé await pour charger le fichier de manière asynchrone, il doit être dans une méthode déclarée comme async private. Pour plus d’informations, voir Démarrage rapide : appel d’API asynchrones en C# ou Visual Basic.

Traitement d’image et bitmaps

Charger et afficher un bitmap, c’est bien, mais le traiter c’est encore mieux. Le code suivant approfondit l’exemple ci-dessus. Il utilise l’objet fichier pour accéder à un flux, puis accède aux données de pixels brutes de l’image. Une nouvelle image WritableBitmap est créée à l’aide de ces données brutes, puis les couleurs sont manipulées avant que l’image ne soit de nouveau affichée.

Remarque  Il est important d’ajouter using System.Runtime.InteropServices.WindowsRuntime;, sinon le code ne sera pas compilé.


               // Add: using Windows.UI.Xaml.Media.Imaging;
                // Add: using System.Runtime.InteropServices.WindowsRuntime;

                int height = bitmapImage.PixelHeight;
                int width = bitmapImage.PixelWidth;

                using (var stream = await file.OpenReadAsync())
                {
                    WriteableBitmap bitmap = new WriteableBitmap(width, height);
                    await bitmap.SetSourceAsync(stream);

                    using (var buffer = bitmap.PixelBuffer.AsStream())
                    {
                        Byte[] pixels = new Byte[4 * width * height];
                        buffer.Read(pixels, 0, pixels.Length);

                        for (int x = 0; x < width; x++)
                        {

                            for (int y = 0; y < height; y++)
                            {
                                int index = ((y * width) + x) * 4;

                                Byte b = pixels[index + 0];
                                Byte g = pixels[index + 1];
                                Byte r = pixels[index + 2];
                                Byte a = pixels[index + 3];

                                // Some simple color manipulation
                                byte newB = (Byte)((r + g) / 2);
                                byte newG = (Byte)((r + b) / 2);
                                byte newR = (Byte)((b + g) / 2);

                                pixels[index + 0] = newB;
                                pixels[index + 1] = newG;
                                pixels[index + 2] = newR;
                                pixels[index + 3] = a;
                            }
                        }

                        buffer.Position = 0;
                        buffer.Write(pixels, 0, pixels.Length);
                        myImage.Source = bitmap;
                    }
                }


Remarque  Si vous prévoyez de traiter le même WriteableBitmap à plusieurs reprises, effectuez un appel à WritableBitmap.Invalidate() à chaque fois.

Rubriques associées

Rubriques pour les développeurs iOS
Ressources pour les développeurs iOS
Contrôles Windows 8 pour les développeurs iOS
Guide de référence Windows 8 pour les développeurs iOS
Sélecteurs de fichiers et rubriques sur les images bitmap
Recommandations pour les sélecteurs de fichiers (applications du Windows Store)
Quatrième partie : accès aux fichiers et sélecteurs
Propriété WriteableBitmap.PixelBuffer

 

 

Afficher:
© 2014 Microsoft