Comment redimensionner une Image en C# WinRT/winmd?

Exemple de la façon dont, à l'échelle et des cultures prises de ici:

async private void BitmapTransformTest()
{
    //hard coded image location
    string filePath = "C:\\Users\\Public\\Pictures\\Sample Pictures\\fantasy-dragons-wallpaper.jpg";

    StorageFile file = await StorageFile.GetFileFromPathAsync(filePath);
    if (file == null)
        return;

    //create a stream from the file and decode the image
    var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read);
    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream);


    //create a new stream and encoder for the new image
    InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();
    BitmapEncoder enc = await BitmapEncoder.CreateForTranscodingAsync(ras, decoder);

    //convert the entire bitmap to a 100px by 100px bitmap
    enc.BitmapTransform.ScaledHeight = 100;
    enc.BitmapTransform.ScaledWidth = 100;


    BitmapBounds bounds = new BitmapBounds();
    bounds.Height = 50;
    bounds.Width = 50;
    bounds.X = 50;
    bounds.Y = 50;
    enc.BitmapTransform.Bounds = bounds;

    //write out to the stream
    try
    {
        await enc.FlushAsync();
    }
    catch (Exception ex)
    {
        string s = ex.ToString();
    }

    //render the stream to the screen
    BitmapImage bImg = new BitmapImage();
    bImg.SetSource(ras);
    img.Source = bImg; //image element in xaml

}

OriginalL'auteur mydogisbox

Voici donc ma solution, je suis venu avec après beaucoup de recherches sur google et essai/erreur de codage:

Le but ici était de savoir, comment manipuler des images dans WinRT, plus précisément dans Tâches En Arrière-Plan. Tâches en arrière-plan sont encore plus limitées que d'ordinaire WinRT projets, parce qu'ils doivent être de type Composant Windows Runtime. 99% de bibliothèques disponibles sur NuGet ciblage WinRT sont de cibler uniquement la valeur par défaut WinRT projets, ils ne peuvent donc pas être utilisés dans Windows Composant d'Exécution des projets.

J'ai d'abord essayé d'utiliser le bien connu WriteableBitmapEx bibliothèque de portage le code nécessaire à mon winmd projet. Il en est de même direction générale de la WBE projet de ciblage winmd, mais elle est restée inachevée. Je l'ai fait compiler après l'ajout de [ReadOnlyArray], [WriteOnlyArray] attributs à la méthode des paramètres de type tableau et après modification du projet d'espace de noms pour quelque chose de pas partir avec des "Fenêtres" - winmd projet de limitation.

Même si j'étais en mesure d'utiliser cette librairie dans ma Tâche en arrière-plan de projet, il n'était pas de travail, parce que, comme je l'ai découvert, WriteableBitmap doit être instancié dans le thread de l'INTERFACE utilisateur et ce n'est pas possible pour autant que je sais en Tâche de Fond.

En attendant, j'ai aussi trouvé ce MSDN article sur la manipulation des Images WinRT. La plupart des échantillons il y a seulement dans la section JavaScript, donc j'ai dû convertir en C# en premier. J'ai aussi trouvé ce utile article sur StackOverflow sur la manipulation des images WinRT.

internal static async Task LoadTileImageInternalAsync(string imagePath)
{
string tileName = imagePath.GetHashedTileName();
StorageFile origFile = await ApplicationData.Current.LocalFolder.GetFileAsync(imagePath);
//open file for the new tile image file
StorageFile tileFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(tileName, CreationCollisionOption.ReplaceExisting);
using (IRandomAccessStream tileStream = await tileFile.OpenAsync(FileAccessMode.ReadWrite))
{
//get width and height from the original image
IRandomAccessStreamWithContentType stream = await origFile.OpenReadAsync();
ImageProperties properties = await origFile.Properties.GetImagePropertiesAsync();
uint width = properties.Width;
uint height = properties.Height;
//get proper decoder for the input file - jpg/png/gif
BitmapDecoder decoder = await GetProperDecoder(stream, imagePath);
if (decoder == null) return; //should not happen
//get byte array of actual decoded image
PixelDataProvider data = await decoder.GetPixelDataAsync();
byte[] bytes = data.DetachPixelData();
//create encoder for saving the tile image
BitmapPropertySet propertySet = new BitmapPropertySet();
//create class representing target jpeg quality - a bit obscure, but it works
BitmapTypedValue qualityValue = new BitmapTypedValue(TargetJpegQuality, PropertyType.Single);
propertySet.Add("ImageQuality", qualityValue);
//create the target jpeg decoder
BitmapEncoder be = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, tileStream, propertySet);
be.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, width, height, 96.0, 96.0, bytes);
//crop the image, if it's too big
if (width > MaxImageWidth || height > MaxImageHeight)
{
BitmapBounds bounds = new BitmapBounds();
if (width > MaxImageWidth)
{
bounds.Width = MaxImageWidth;
bounds.X = (width - MaxImageWidth) / 2;
}
else bounds.Width = width;
if (height > MaxImageHeight)
{
bounds.Height = MaxImageHeight;
bounds.Y = (height - MaxImageHeight) / 2;
}
else bounds.Height = height;
be.BitmapTransform.Bounds = bounds;
}
//save the target jpg to the file
await be.FlushAsync();
}
}
private static async Task<BitmapDecoder> GetProperDecoder(IRandomAccessStreamWithContentType stream, string imagePath)
{
string ext = Path.GetExtension(imagePath);
switch (ext)
{
case ".jpg":
case ".jpeg":
return await BitmapDecoder.CreateAsync(BitmapDecoder.JpegDecoderId, stream);
case ".png":
return await BitmapDecoder.CreateAsync(BitmapDecoder.PngDecoderId, stream);
case ".gif":
return await BitmapDecoder.CreateAsync(BitmapDecoder.GifDecoderId, stream);
}
return null;
}

Dans cet exemple, nous ouvrir un fichier, de le décoder en tableau d'octets, et l'encoder de retour dans un nouveau fichier avec une taille différente/format/la qualité.

Le résultat est entièrement de travail de manipulation de l'image, même dans Windows Runtime Classe de Composant et sans WriteableBitmapEx bibliothèque.

OriginalL'auteur Martin Suchan

Je viens de passer la dernière heure et demi à essayer de comprendre de ça, j'ai un tableau d'octets qui est un JPG et a essayé de la réponse donnée... je ne pouvais pas le faire fonctionner je suis donc de mettre en place une nouvelle réponse... j'espère que cela aidera quelqu'un d'autre... je suis de convertir le JPG à 250/250 pixels

private async Task<BitmapImage> ByteArrayToBitmapImage(byte[] byteArray)
{
BitmapImage image = new BitmapImage();
using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream())
{
using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)))
{
writer.WriteBytes((byte[])byteArray);
writer.StoreAsync().GetResults();
}
image.SetSource(stream);
}
image.DecodePixelHeight = 250;
image.DecodePixelWidth = 250;
return image;            
}

OriginalL'auteur Stuart Smith