コード例 #1
0
        public async static Task <WriteableBitmap> ToBitmapImageAsync(this byte[] imageBytes, Tuple <int, int> downscale, InterpolationMode mode)
        {
            if (imageBytes == null)
            {
                return(null);
            }

            IRandomAccessStream image = imageBytes.AsBuffer().AsStream().AsRandomAccessStream();

            if (downscale != null && (downscale.Item1 > 0 || downscale.Item2 > 0))
            {
                image = await image.ResizeImage((uint)downscale.Item1, (uint)downscale.Item2, mode).ConfigureAwait(false);
            }

            using (image)
            {
                BitmapDecoder decoder = await BitmapDecoder.CreateAsync(image);

                image.Seek(0);

                WriteableBitmap bitmap = null;

                await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, async() =>
                {
                    bitmap = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                    await bitmap.SetSourceAsync(image);
                });

                return(bitmap);
            }
        }
コード例 #2
0
        public async static Task <BitmapHolder> ToBitmapHolderAsync(this byte[] imageBytes, Tuple <int, int> downscale, InterpolationMode mode)
        {
            if (imageBytes == null)
            {
                return(null);
            }

            IRandomAccessStream image = imageBytes.AsBuffer().AsStream().AsRandomAccessStream();

            if (downscale != null && (downscale.Item1 > 0 || downscale.Item2 > 0))
            {
                image = await image.ResizeImage((uint)downscale.Item1, (uint)downscale.Item2, mode).ConfigureAwait(false);
            }

            using (image)
            {
                BitmapDecoder decoder = await BitmapDecoder.CreateAsync(image);

                PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync();

                var   bytes = pixelDataProvider.DetachPixelData();
                int[] array = new int[decoder.PixelWidth * decoder.PixelHeight];
                CopyPixels(bytes, array);

                return(new BitmapHolder(array, (int)decoder.PixelWidth, (int)decoder.PixelHeight));
            }
        }
コード例 #3
0
        public async static Task <WriteableBitmap> ToBitmapImageAsync(this Stream imageStream, Tuple <int, int> downscale, bool downscaleDipUnits, InterpolationMode mode, bool allowUpscale, ImageInformation imageInformation = null)
        {
            if (imageStream == null)
            {
                return(null);
            }

            using (IRandomAccessStream image = imageStream.AsRandomAccessStream())
            {
                if (downscale != null && (downscale.Item1 > 0 || downscale.Item2 > 0))
                {
                    using (var downscaledImage = await image.ResizeImage(downscale.Item1, downscale.Item2, mode, downscaleDipUnits, allowUpscale, imageInformation).ConfigureAwait(false))
                    {
                        BitmapDecoder decoder = await BitmapDecoder.CreateAsync(downscaledImage);

                        downscaledImage.Seek(0);
                        WriteableBitmap resizedBitmap = null;

                        await MainThreadDispatcher.Instance.PostAsync(async() =>
                        {
                            resizedBitmap = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                            await resizedBitmap.SetSourceAsync(downscaledImage);
                        });

                        return(resizedBitmap);
                    }
                }
                else
                {
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(image);

                    image.Seek(0);
                    WriteableBitmap bitmap = null;

                    if (imageInformation != null)
                    {
                        imageInformation.SetCurrentSize((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                        imageInformation.SetOriginalSize((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                    }

                    await MainThreadDispatcher.Instance.PostAsync(async() =>
                    {
                        bitmap = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                        await bitmap.SetSourceAsync(image);
                    });

                    return(bitmap);
                }
            }
        }
コード例 #4
0
        public async static Task <BitmapHolder> ToBitmapHolderAsync(this Stream imageStream, Tuple <int, int> downscale, bool downscaleDipUnits, InterpolationMode mode, bool allowUpscale, ImageInformation imageInformation = null)
        {
            if (imageStream == null)
            {
                return(null);
            }

            using (IRandomAccessStream image = imageStream.AsRandomAccessStream())
            {
                if (downscale != null && (downscale.Item1 > 0 || downscale.Item2 > 0))
                {
                    using (var downscaledImage = await image.ResizeImage(downscale.Item1, downscale.Item2, mode, downscaleDipUnits, allowUpscale, imageInformation).ConfigureAwait(false))
                    {
                        BitmapDecoder decoder = await BitmapDecoder.CreateAsync(downscaledImage);

                        PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync(
                            BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, new BitmapTransform(),
                            ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage);

                        var bytes = pixelDataProvider.DetachPixelData();

                        return(new BitmapHolder(bytes, (int)decoder.PixelWidth, (int)decoder.PixelHeight));
                    }
                }
                else
                {
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(image);

                    PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync(
                        BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, new BitmapTransform(),
                        ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage);

                    if (imageInformation != null)
                    {
                        imageInformation.SetCurrentSize((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                        imageInformation.SetOriginalSize((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                    }

                    var bytes = pixelDataProvider.DetachPixelData();

                    return(new BitmapHolder(bytes, (int)decoder.PixelWidth, (int)decoder.PixelHeight));
                }
            }
        }
コード例 #5
0
        public async static Task <BitmapHolder> ToBitmapHolderAsync(this Stream imageStream, Tuple <int, int> downscale, bool downscaleDipUnits, InterpolationMode mode, ImageInformation imageInformation = null)
        {
            if (imageStream == null)
            {
                return(null);
            }

            using (IRandomAccessStream image = imageStream.AsRandomAccessStream())
            {
                if (downscale != null && (downscale.Item1 > 0 || downscale.Item2 > 0))
                {
                    using (var downscaledImage = await image.ResizeImage(downscale.Item1, downscale.Item2, mode, downscaleDipUnits, imageInformation).ConfigureAwait(false))
                    {
                        BitmapDecoder decoder = await BitmapDecoder.CreateAsync(downscaledImage);

                        PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync();

                        var   bytes = pixelDataProvider.DetachPixelData();
                        int[] array = new int[decoder.PixelWidth * decoder.PixelHeight];
                        CopyPixels(bytes, array);

                        return(new BitmapHolder(array, (int)decoder.PixelWidth, (int)decoder.PixelHeight));
                    }
                }
                else
                {
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(image);

                    PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync();

                    if (imageInformation != null)
                    {
                        imageInformation.SetCurrentSize((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                        imageInformation.SetOriginalSize((int)decoder.PixelWidth, (int)decoder.PixelHeight);
                    }

                    var   bytes = pixelDataProvider.DetachPixelData();
                    int[] array = new int[decoder.PixelWidth * decoder.PixelHeight];
                    CopyPixels(bytes, array);

                    return(new BitmapHolder(array, (int)decoder.PixelWidth, (int)decoder.PixelHeight));
                }
            }
        }