public async Task ConverterBitmapToTargetStreamAsync(IRandomAccessStream bitmapSourceStream, IRandomAccessStream saveTargetStream) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(bitmapSourceStream); // Scale image to appropriate size BitmapTransform transform = new BitmapTransform() { //ScaledWidth = Convert.ToUInt32(bi.PixelWidth), //ScaledHeight = Convert.ToUInt32(bi.PixelHeight) }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, // WriteableBitmap uses BGRA format BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, // This sample ignores Exif orientation ColorManagementMode.DoNotColorManage); var BitmapEncoderGuid = BitmapEncoder.PngEncoderId; BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoderGuid, saveTargetStream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)decoder.PixelWidth, (uint)decoder.PixelHeight, 96.0, 96.0, pixelData.DetachPixelData()); await encoder.FlushAsync(); }
private async void DisplayImage(byte[] img, int imageType) { if (Displayer != null) { try { // Decode the JPEG BitmapDecoder decoder = await BitmapDecoder.CreateAsync(ConvertTo(img)); PixelDataProvider pixelData = await decoder.GetPixelDataAsync(); byte[] decompressedImage = pixelData.DetachPixelData(); uint width = decoder.PixelWidth; uint height = decoder.PixelHeight; // TODO: Convert SoftwareBitmap to matrix and pass to ImageDisplayer if (imageType == RECEIVING_RGB) { // TODO: Make Display methods take the one dimensional decompressed byte array byte[,,] decompressedRGBMatrix = ConvertDecompressedToRGBMatrix(decompressedImage, width, height); Displayer.DisplayRGB(decompressedImage); } else if (imageType == RECEIVING_ONE_BAND) { // Displayer.DisplayOneBand(decompressedImage); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } } }
public async Task <byte[]> GetScaledPixelsAsync(int height, int width) { using (IRandomAccessStream fileStream = await m_file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); // Scale image to appropriate size BitmapTransform transform = new BitmapTransform() { ScaledWidth = Convert.ToUInt32(width), ScaledHeight = Convert.ToUInt32(height) }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, // WriteableBitmap uses BGRA format BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, // This sample ignores Exif orientation ColorManagementMode.DoNotColorManage ); // An array containing the decoded image data, which could be modified before being displayed byte[] sourcePixels = pixelData.DetachPixelData(); return(sourcePixels); } }
public static async Task <Image <TColor, TDepth> > FromStorageFile(StorageFile file) { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); Size s = new Size((int)decoder.PixelWidth, (int)decoder.PixelHeight); BitmapTransform transform = new BitmapTransform(); PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); byte[] sourcePixels = pixelData.DetachPixelData(); GCHandle handle = GCHandle.Alloc(sourcePixels, GCHandleType.Pinned); using (Image <Bgra, Byte> img = new Image <Bgra, byte>(s.Width, s.Height, s.Width * 4, handle.AddrOfPinnedObject())) { Image <TColor, TDepth> result = new Image <TColor, TDepth>(img.Size); result.ConvertFrom(img); handle.Free(); return(result); } } }
public async void LoadBitmap(string name) { StorageFile srcfile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(name)); using (IRandomAccessStream fileStream = await srcfile.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); BitmapTransform transform = new BitmapTransform() { ScaledWidth = 8, ScaledHeight = 8 }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage ); byte[] sourcePixels = pixelData.DetachPixelData(); byte[] hatPixels = new byte[192]; for (int i = 0; i < (sourcePixels.Length / 4) / 8; i++) { MapToHat(hatPixels, i * 8 * 3, sourcePixels, i * 8 * 4); } WriteLEDMatrix(hatPixels); } }
private async void openFile_click(object sender, RoutedEventArgs e) { FileOpenPicker openPicker = new FileOpenPicker(); openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; openPicker.FileTypeFilter.Add(".png"); openPicker.FileTypeFilter.Add(".jpeg"); openPicker.FileTypeFilter.Add(".jpg"); openPicker.FileTypeFilter.Add(".bmp"); StorageFile file = await openPicker.PickSingleFileAsync(); if (file != null) { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); OryginalWriteableBitmapMainImage = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight); WriteableBitmapMainImage = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight); OryginalLayer_Image.Source = OryginalWriteableBitmapMainImage; FilteredLayer_Image.Source = WriteableBitmapMainImage; BitmapTransform transform = new BitmapTransform() { ScaledWidth = Convert.ToUInt32(WriteableBitmapMainImage.PixelWidth), ScaledHeight = Convert.ToUInt32(WriteableBitmapMainImage.PixelHeight) }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); byte[] sourcePixels = pixelData.DetachPixelData(); orygPixels = (byte[])sourcePixels.Clone(); // copy pixels to filtered layer using (Stream stream = WriteableBitmapMainImage.PixelBuffer.AsStream()) { await stream.WriteAsync(sourcePixels, 0, sourcePixels.Length); fileName_textBlock.Text = file.Name; } // copy pixels to oryginal layer using (Stream stream = OryginalWriteableBitmapMainImage.PixelBuffer.AsStream()) { await stream.WriteAsync(orygPixels, 0, sourcePixels.Length); } } WriteableBitmapMainImage.Invalidate(); OryginalWriteableBitmapMainImage.Invalidate(); } }
private async Task ResizeImage(StorageFile sourceFile, StorageFile destinationFile) { using (var sourceStream = await sourceFile.OpenAsync(FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(sourceStream); var newWidth = Math.Min(800, decoder.PixelWidth); var newHeight = newWidth * decoder.PixelHeight / decoder.PixelWidth; BitmapTransform transform = new BitmapTransform() { ScaledHeight = newHeight, ScaledWidth = newWidth }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); using (var destinationStream = await destinationFile.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, destinationStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, newWidth, newHeight, 96, 96, pixelData.DetachPixelData()); await encoder.FlushAsync(); } } }
/// <summary> /// 读取照片流 转为WriteableBitmap给二维码解码器 /// </summary> /// <param name="fileStream"></param> /// <param name="type"></param> /// <returns></returns> public async static Task <WriteableBitmap> ReadBitmap(IRandomAccessStream fileStream, string type) { WriteableBitmap bitmap = null; try { Guid decoderId = DecoderIDFromFileExtension(type); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(decoderId, fileStream); BitmapTransform tf = new BitmapTransform(); uint width = decoder.OrientedPixelWidth; uint height = decoder.OrientedPixelHeight; double dScale = 1; if (decoder.OrientedPixelWidth > MaxSizeSupported.Width || decoder.OrientedPixelHeight > MaxSizeSupported.Height) { dScale = Math.Min(MaxSizeSupported.Width / decoder.OrientedPixelWidth, MaxSizeSupported.Height / decoder.OrientedPixelHeight); width = (uint)(decoder.OrientedPixelWidth * dScale); height = (uint)(decoder.OrientedPixelHeight * dScale); tf.ScaledWidth = (uint)(decoder.PixelWidth * dScale); tf.ScaledHeight = (uint)(decoder.PixelHeight * dScale); } bitmap = new WriteableBitmap((int)width, (int)height); PixelDataProvider dataprovider = await decoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, tf, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); byte[] pixels = dataprovider.DetachPixelData(); Stream pixelStream2 = bitmap.PixelBuffer.AsStream(); pixelStream2.Write(pixels, 0, pixels.Length); //bitmap.SetSource(fileStream); } catch { } return(bitmap); }
private async Task <byte[]> ImageToBytes(IRandomAccessStream sourceStream) { byte[] imageArray; BitmapDecoder decoder = await BitmapDecoder.CreateAsync(sourceStream); var transform = new BitmapTransform { ScaledWidth = decoder.PixelWidth, ScaledHeight = decoder.PixelHeight }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); using (var destinationStream = new InMemoryRandomAccessStream()) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, decoder.PixelWidth, decoder.PixelHeight, 96, 96, pixelData.DetachPixelData()); await encoder.FlushAsync(); BitmapDecoder outputDecoder = await BitmapDecoder.CreateAsync(destinationStream); await destinationStream.FlushAsync(); imageArray = (await outputDecoder.GetPixelDataAsync()).DetachPixelData(); } return(imageArray); }
private static async Task <WriteableBitmap> GetImageFile(Uri fileUri) { StorageFile imageFile = await StorageFile.GetFileFromApplicationUriAsync(fileUri); WriteableBitmap writeableBitmap = null; using (IRandomAccessStream imageStream = await imageFile.OpenReadAsync()) { BitmapDecoder bitmapDecoder = await BitmapDecoder.CreateAsync(imageStream); BitmapTransform dummyTransform = new BitmapTransform(); PixelDataProvider pixelDataProvider = await bitmapDecoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, dummyTransform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.ColorManageToSRgb); byte[] pixelData = pixelDataProvider.DetachPixelData(); writeableBitmap = new WriteableBitmap( (int)bitmapDecoder.OrientedPixelWidth, (int)bitmapDecoder.OrientedPixelHeight); using (Stream pixelStream = writeableBitmap.PixelBuffer.AsStream()) { await pixelStream.WriteAsync(pixelData, 0, pixelData.Length); } } return(writeableBitmap); }
private async Task <WriteableBitmap> ReadAsync() { // 파일로부터 IRandomAccessStream를 가져오고 using (IRandomAccessStream stream = await _file.OpenAsync(FileAccessMode.ReadWrite)) { //BitmapDecoder로 이미지를 가져온다 BitmapDecoder decoder = await BitmapDecoder.CreateAsync(BitmapDecoder.JpegDecoderId, stream); uint width = decoder.PixelWidth; uint height = decoder.PixelHeight; if (_angle % 180 != 0) { width = decoder.PixelHeight; height = decoder.PixelWidth; } // 그런 다음 사진을 조작하여 변형을 반영한다. BitmapTransform transform = new BitmapTransform { Rotation = rotation_angles[_angle] }; // PixelDataProvider를 이용하여 사진을 회전 PixelDataProvider data = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); _bitmap = new WriteableBitmap((int)width, (int)height); // 이후 정보를 파일에 다시 기록하여 회전된 이미지를 생성 byte[] buffer = data.DetachPixelData(); using (Stream pixels = _bitmap.PixelBuffer.AsStream()) { pixels.Write(buffer, 0, (int)pixels.Length); } } return(_bitmap); }
public static async Task <BitmapSource> CreateScaledBitmapFromStreamAsync(WebView web, IRandomAccessStream source) { int height = Convert.ToInt32(web.ActualHeight); int width = Convert.ToInt32(web.ActualWidth); WriteableBitmap bitmap = new WriteableBitmap(width, height); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(source); BitmapTransform transform = new BitmapTransform(); transform.ScaledHeight = (uint)height; transform.ScaledWidth = (uint)width; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); pixelData.DetachPixelData().CopyTo(bitmap.PixelBuffer); var savefile = await ApplicationData.Current.LocalFolder.CreateFileAsync("inkSample", CreationCollisionOption.ReplaceExisting); using (IRandomAccessStream stream = await savefile.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream); Stream pixelStream = bitmap.PixelBuffer.AsStream(); byte[] pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0, pixels.Length); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)bitmap.PixelWidth, (uint)bitmap.PixelHeight, 96.0, 96.0, pixels); await encoder.FlushAsync(); } return(bitmap); }
/// <summary> /// Use BitmapTransform to define the region to crop, and then get the pixel data in the region. /// If you want to get the pixel data of a scaled image, set the scaledWidth and scaledHeight /// of the scaled image. /// </summary> async static private Task <byte[]> GetPixelData(BitmapDecoder decoder, uint startPointX, uint startPointY, uint width, uint height, uint scaledWidth, uint scaledHeight) { BitmapTransform transform = new BitmapTransform(); BitmapBounds bounds = new BitmapBounds(); bounds.X = startPointX; bounds.Y = startPointY; bounds.Height = height; bounds.Width = width; transform.Bounds = bounds; transform.ScaledWidth = scaledWidth; transform.ScaledHeight = scaledHeight; // Get the cropped pixels within the bounds of transform. PixelDataProvider pix = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb); byte[] pixels = pix.DetachPixelData(); return(pixels); }
public static async Task <IRandomAccessStream> ImageToJPegStreamAsync(IRandomAccessStream imageStream) { //Create a decoder for the image var decoder = await BitmapDecoder.CreateAsync(imageStream); PixelDataProvider pixelData = await decoder.GetPixelDataAsync(); byte[] pixelBytes = pixelData.DetachPixelData(); // InMemoryRandomAccessStream jpegStream = new InMemoryRandomAccessStream(); double jpegImageQuality = 0.9; var propertySet = new BitmapPropertySet(); var qualityValue = new BitmapTypedValue(jpegImageQuality, Windows.Foundation.PropertyType.Single); propertySet.Add("ImageQuality", qualityValue); var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, jpegStream, propertySet); //key thing here is to use decoder.OrientedPixelWidth and decoder.OrientedPixelHeight otherwise you will get garbled image on devices on some photos with orientation in metadata encoder.SetPixelData(decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, decoder.OrientedPixelWidth, decoder.OrientedPixelHeight, decoder.DpiX, decoder.DpiY, pixelBytes); //ulong jpegImageSize = 0; //jpegImageSize = jpegStream.Size; await encoder.FlushAsync(); await jpegStream.FlushAsync(); return(jpegStream); }
private async Task ResizeToJpegPhoto(IRandomAccessStream inputStream, IRandomAccessStream outputStream, uint maxSize) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(inputStream); double scaleFactor = 1.0; uint pixelSize = decoder.PixelWidth > decoder.PixelHeight ? decoder.PixelWidth : decoder.PixelHeight; if (pixelSize > maxSize) { scaleFactor = (double)maxSize / pixelSize; } BitmapTransform transform = new BitmapTransform(); transform.ScaledWidth = (uint)(decoder.PixelWidth * scaleFactor); transform.ScaledHeight = (uint)(decoder.PixelHeight * scaleFactor); transform.InterpolationMode = BitmapInterpolationMode.Fant; BitmapPixelFormat pixelFormat = decoder.BitmapPixelFormat; BitmapAlphaMode alphaMode = decoder.BitmapAlphaMode; PixelDataProvider pixelDataProvider = await decoder.GetPixelDataAsync(pixelFormat, alphaMode, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); var pixels = pixelDataProvider.DetachPixelData(); uint finalWidth = (uint)(decoder.OrientedPixelWidth * scaleFactor); uint finalHeight = (uint)(decoder.OrientedPixelHeight * scaleFactor); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, outputStream); encoder.SetPixelData(pixelFormat, alphaMode, finalWidth, finalHeight, decoder.DpiX, decoder.DpiY, pixels); await encoder.FlushAsync(); }
public async Task <WriteableBitmap> GetImage() { if (this.mediaCapture == null) { return(null); } InMemoryRandomAccessStream inStream = new InMemoryRandomAccessStream(); await this.mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), inStream); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(inStream); BitmapTransform transform = new BitmapTransform(); PixelDataProvider provider = await decoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); byte[] sourcePixels = provider.DetachPixelData(); WriteableBitmap bmp = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight); using (Stream outputStream = bmp.PixelBuffer.AsStream()) { await outputStream.WriteAsync(sourcePixels, 0, sourcePixels.Length); } return(bmp); }
async private static Task <byte[]> GetCroppedPixelsAsync(IRandomAccessStream stream, FaceRectangle rectangle) { // Create a decoder from the stream. With the decoder, we can get // the properties of the image. BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); // Create cropping BitmapTransform and define the bounds. BitmapTransform transform = new BitmapTransform(); BitmapBounds bounds = new BitmapBounds(); bounds.X = (uint)rectangle.Left; bounds.Y = (uint)rectangle.Top; bounds.Height = (uint)rectangle.Height; bounds.Width = (uint)rectangle.Width; transform.Bounds = bounds; // Get the cropped pixels within the bounds of transform. PixelDataProvider pix = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb); return(pix.DetachPixelData()); }
public static async Task <WriteableBitmap> StorageFileToWriteableBitmapWithDirection(StorageFile file) { if (file == null) { return(null); } using (IRandomAccessStream stream = await file.OpenReadAsync()) { // Create a decoder from the stream. With the decoder, we can get // the properties of the image. BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); PixelDataProvider pix = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, new BitmapTransform(), ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); byte[] pixels = pix.DetachPixelData(); WriteableBitmap Bmp = new WriteableBitmap((int)decoder.OrientedPixelWidth, (int)decoder.OrientedPixelHeight); Stream pixStream = Bmp.PixelBuffer.AsStream(); pixStream.Write(pixels, 0, (int)(decoder.OrientedPixelWidth * decoder.OrientedPixelHeight * 4)); return(Bmp); } }
public static async Task ToArray(this StorageFile file, IOutputArray result, ImreadModes modes = ImreadModes.AnyColor | ImreadModes.AnyDepth) { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); Size s = new Size((int)decoder.PixelWidth, (int)decoder.PixelHeight); BitmapTransform transform = new BitmapTransform(); PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); byte[] sourcePixels = pixelData.DetachPixelData(); GCHandle handle = GCHandle.Alloc(sourcePixels, GCHandleType.Pinned); using (Image <Bgra, Byte> img = new Image <Bgra, byte>(s.Width, s.Height, s.Width * 4, handle.AddrOfPinnedObject())) { if (modes.HasFlag(ImreadModes.Grayscale)) { CvInvoke.CvtColor(img, result, ColorConversion.Bgra2Gray); } else { CvInvoke.CvtColor(img, result, ColorConversion.Bgra2Bgr); } handle.Free(); } } }
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)); } }
async protected override void OnTapped(TappedRoutedEventArgs args) { if (ignoreTaps) { return; } // Capture photo to memory stream ImageEncodingProperties imageEncodingProps = ImageEncodingProperties.CreateJpeg(); InMemoryRandomAccessStream memoryStream = new InMemoryRandomAccessStream(); await mediaCapture.CapturePhotoToStreamAsync(imageEncodingProps, memoryStream); // Use BitmapDecoder to get pixels array BitmapDecoder decoder = await BitmapDecoder.CreateAsync(memoryStream); PixelDataProvider pixelProvider = await decoder.GetPixelDataAsync(); byte[] pixels = pixelProvider.DetachPixelData(); // Saturate the colors for (int index = 0; index < pixels.Length; index += 4) { Color color = Color.FromArgb(pixels[index + 3], pixels[index + 2], pixels[index + 1], pixels[index + 0]); HSL hsl = new HSL(color); hsl = new HSL(hsl.Hue, 1.0, hsl.Lightness); color = hsl.Color; pixels[index + 0] = color.B; pixels[index + 1] = color.G; pixels[index + 2] = color.R; pixels[index + 3] = color.A; } // Create a WriteableBitmap and initialize it WriteableBitmap bitmap = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight); Stream pixelStream = bitmap.PixelBuffer.AsStream(); await pixelStream.WriteAsync(pixels, 0, pixels.Length); bitmap.Invalidate(); // Display the bitmap image.Source = bitmap; // Set a timer for the image DispatcherTimer timer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(2.5) }; timer.Tick += OnTimerTick; timer.Start(); ignoreTaps = true; base.OnTapped(args); }
private async void CUButton_Click(object sender, RoutedEventArgs e) { if (title.Text == "") { var i = new MessageDialog("Title Empty!").ShowAsync(); return; } if (detail.Text == "") { var i = new MessageDialog("Detail Empty!").ShowAsync(); return; } if (date.Date.Date < DateTime.Today.Date) { var i = new MessageDialog("Invalid Date!").ShowAsync(); return; } if (CUButton.Content.ToString() == "Create") { WriteableBitmap defaultimage = null; StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/background.jpg")); if (file != null) { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder bitmapDecoder = await BitmapDecoder.CreateAsync(fileStream); BitmapTransform dummyTransform = new BitmapTransform(); PixelDataProvider pixelDataProvider = await bitmapDecoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, dummyTransform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.ColorManageToSRgb); byte[] pixelData = pixelDataProvider.DetachPixelData(); defaultimage = new WriteableBitmap( (int)bitmapDecoder.OrientedPixelWidth, (int)bitmapDecoder.OrientedPixelHeight); using (Stream pixelStream = defaultimage.PixelBuffer.AsStream()) { await pixelStream.WriteAsync(pixelData, 0, pixelData.Length); } } } ViewModel.AddTodoItem(title.Text, detail.Text, defaultimage, date.Date.DateTime); //Frame.Navigate(typeof(MainPage), ViewModel); } else { ViewModel.UpdateTodoItem(ViewModel.SelectedItem.id, title.Text, detail.Text, date.Date.DateTime); CUButton.Content = "Create"; //Frame.Navigate(typeof(MainPage), ViewModel); } }
public IAsyncInfo GenerateGif(StorageFile outputFile, int delay, bool repeat, List <byte[]> sourceBytes) { return(AsyncInfo.Run(async ctx => { var outStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.GifEncoderId, outStream); if (repeat) // set repeat property { var containerProperties = new BitmapPropertySet { { "/appext/Application", new BitmapTypedValue(Encoding.UTF8.GetBytes("NETSCAPE2.0"), PropertyType.UInt8Array) }, { "/appext/Data", new BitmapTypedValue(new byte[] { 3, 1, 0, 0, 0 }, PropertyType.UInt8Array) }, }; await encoder.BitmapContainerProperties.SetPropertiesAsync(containerProperties); } try { for (int i = 0; i < sourceBytes.Count; i++) { using (MemoryRandomAccessStream frameStream = new MemoryRandomAccessStream(sourceBytes[i])) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(frameStream); PixelDataProvider pixels = await decoder.GetPixelDataAsync(); encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore, decoder.OrientedPixelWidth, decoder.OrientedPixelHeight, decoder.DpiX, decoder.DpiY, pixels.DetachPixelData()); if (i == 0) { var properties = new BitmapPropertySet { { "/grctlext/Delay", new BitmapTypedValue(delay / 10, PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); } if (i < sourceBytes.Count - 1) { await encoder.GoToNextFrameAsync(); } } } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("exception caught: " + ex.ToString()); // throw ex; } await encoder.FlushAsync(); outStream.Dispose(); })); }
public static async Task <WriteableBitmap> Resize(StorageFile file, double sizeMax) { IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); double sourceWidth = (double)decoder.PixelWidth; double sourceHeight = (double)decoder.PixelHeight; double width = sourceWidth; double height = sourceHeight; bool needResize = false; double WtoH = sourceWidth / sourceHeight; if (WtoH > 1d)//width is longer { if (sourceWidth > sizeMax) { width = sizeMax; height = width * sourceHeight / sourceWidth; needResize = true; } } else//height is longer { if (sourceHeight > sizeMax) { height = sizeMax; width = height * sourceWidth / sourceHeight; needResize = true; } } WriteableBitmap wb = null; wb = new WriteableBitmap((int)width, (int)height); if (needResize) { BitmapTransform transform = new BitmapTransform() { ScaledWidth = (uint)width, ScaledHeight = (uint)height }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); byte[] pixelBuffer = pixelData.DetachPixelData(); wb = wb.FromByteArray(pixelBuffer); } else { wb.SetSource(stream); } return(wb); }
public async Task <StorageFile> GetCroppedBitmapAsync1(StorageFile savedStorageFile, uint startPointX, uint startPointY, uint width, uint height, double scale) { using (IRandomAccessStream stream = await savedStorageFile.OpenReadAsync()) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); uint scaledWidth = (uint)Math.Floor(decoder.PixelWidth * scale); uint scaledHeight = (uint)Math.Floor(decoder.PixelHeight * scale); BitmapTransform transform = new BitmapTransform(); BitmapBounds bounds = new BitmapBounds(); bounds.X = startPointX; bounds.Y = startPointY; bounds.Height = height; bounds.Width = width; transform.Bounds = bounds; PixelDataProvider pix = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb); byte[] pixels = pix.DetachPixelData(); // Stream the bytes into a WriteableBitmap WriteableBitmap cropBmp = new WriteableBitmap((int)width, (int)height); Stream pixStream = cropBmp.PixelBuffer.AsStream(); pixStream.Write(pixels, 0, (int)(width * height * 4)); var fileName = Guid.NewGuid() + "Bps1.jpg"; Guid bitMapEncoderGuid = BitmapEncoder.JpegEncoderId; var file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName); using (var irStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { // var bmenc = await BitmapEncoder.CreateAsync(bitMapEncoderGuid, irStream); var bmenc = await BitmapEncoder.CreateForTranscodingAsync(irStream, decoder); Stream sstrm = cropBmp.PixelBuffer.AsStream(); byte[] pxls = new byte[sstrm.Length]; await sstrm.ReadAsync(pxls, 0, pxls.Length); bmenc.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)cropBmp.PixelWidth, (uint)cropBmp.PixelHeight, scaledWidth, scaledHeight, pxls); await bmenc.FlushAsync(); } return(file); } }
async Task ColorizeCustomButtonAsync(Windows.UI.Color newColor) { // Get the bitmap from the png var sourceUri = new Uri("ms-appx:///Assets/ButtonIconFill.png"); StorageFile storageFile = await StorageFile.GetFileFromApplicationUriAsync(sourceUri); using (IRandomAccessStream readableStream = await storageFile.OpenAsync(FileAccessMode.Read)) { BitmapDecoder bitmapDecoder = await BitmapDecoder.CreateAsync(readableStream); // Get the raw pixel data from the bitmap var dummyTransform = new BitmapTransform(); PixelDataProvider pixelDataProvider = await bitmapDecoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, dummyTransform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); byte[] pixelData = pixelDataProvider.DetachPixelData(); // We now have direct access to the pixels. for (uint row = 0; row < bitmapDecoder.PixelHeight; row++) { for (uint col = 0; col < bitmapDecoder.PixelWidth; col++) { var offset = (row * (int)bitmapDecoder.PixelWidth * 4) + (col * 4); // Replace the pixel with newColor if it is our color key. if ((pixelData[offset] <= 0x01) && (pixelData[offset + 1] <= 0x01) && (pixelData[offset + 2] <= 0x01) && (pixelData[offset + 3] != 0x00)) { pixelData[offset] = newColor.B; pixelData[offset + 1] = newColor.G; pixelData[offset + 2] = newColor.R; pixelData[offset + 3] = newColor.A; } } } // Create a bitmap from our modified pixel data. var bitmap = new WriteableBitmap((int)bitmapDecoder.PixelWidth, (int)bitmapDecoder.PixelHeight); using (Stream pixelStream = bitmap.PixelBuffer.AsStream()) { await pixelStream.WriteAsync(pixelData, 0, pixelData.Length); pixelStream.Flush(); bitmap.Invalidate(); } CustomButtonFill.Source = bitmap; } }
public async Task <Byte[]> ImageFileToByteArray(StorageFile file) { IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); PixelDataProvider pixelData = await decoder.GetPixelDataAsync(); return(pixelData.DetachPixelData()); }
public static async Task <(byte[] decodedBytes, uint newWidth, uint newHeight)> ResizeImageAsync(this BitmapDecoder decoder, uint maximumWidth, uint maximumHeight) { (byte[] decodedBytes, uint newWidth, uint newHeight)returnValue = (null, 0, 0); if (decoder.PixelHeight > maximumHeight || decoder.PixelWidth > maximumWidth) { using (InMemoryRandomAccessStream resizedStream = new InMemoryRandomAccessStream()) { BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(resizedStream, decoder); double widthRatio = (double)maximumWidth / decoder.PixelWidth; double heightRatio = (double)maximumHeight / decoder.PixelHeight; double scaleRatio = Math.Min(widthRatio, heightRatio); if (maximumWidth == 0) { scaleRatio = heightRatio; } if (maximumHeight == 0) { scaleRatio = widthRatio; } returnValue.newHeight = (uint)Math.Floor(decoder.PixelHeight * scaleRatio); returnValue.newWidth = (uint)Math.Floor(decoder.PixelWidth * scaleRatio); encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Linear; encoder.BitmapTransform.ScaledHeight = returnValue.newHeight; encoder.BitmapTransform.ScaledWidth = returnValue.newWidth; await encoder.FlushAsync(); resizedStream.Seek(0); byte[] resizedEncodedBytes = new byte[resizedStream.Size]; await resizedStream.ReadAsync(resizedEncodedBytes.AsBuffer(), (uint)resizedStream.Size, InputStreamOptions.None); using (MemoryStream memoryStream = new MemoryStream(resizedEncodedBytes)) { using (IRandomAccessStream imageStream = memoryStream.AsRandomAccessStream()) { BitmapDecoder decoder2 = await BitmapDecoder.CreateAsync(imageStream); PixelDataProvider data = await decoder2.GetPixelDataAsync(); returnValue.decodedBytes = data.DetachPixelData(); } } } } return(returnValue); }
// Zone File public async void LoadFile(ushort[] photo, uint w, uint h, string name) { StorageFile srcfile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(name)); using (IRandomAccessStream fileStream = await srcfile.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); BitmapTransform transform = new BitmapTransform() { ScaledWidth = Convert.ToUInt32(w), ScaledHeight = Convert.ToUInt32(h) }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); byte[] sourcePixels = pixelData.DetachPixelData(); if (sourcePixels.Length == w * h * 4) { int pi = 0; int i = 0; byte red = 0, green = 0, blue = 0; foreach (byte b in sourcePixels) { switch (i) { case 0: blue = b; break; case 1: green = b; break; case 2: red = b; break; case 3: photo[pi] = RGB888ToRGB565(red, green, blue); pi++; break; } i = (i + 1) % 4; } } else { return; } } }
public static async Task <Uri> ResizeImage(Uri uri, uint size) { if (uri.IsFile) { return(uri); } var response = await HttpWebRequest.Create(uri).GetResponseAsync(); List <Byte> allBytes = new List <byte>(); using (Stream imageStream = response.GetResponseStream()) { InMemoryRandomAccessStream downloadedImageRas = new InMemoryRandomAccessStream(); await RandomAccessStream.CopyAndCloseAsync(imageStream.AsInputStream(), downloadedImageRas.GetOutputStreamAt(0)); BitmapDecoder bmpDecoder = await BitmapDecoder.CreateAsync(downloadedImageRas); BitmapFrame frame = await bmpDecoder.GetFrameAsync(0); BitmapTransform bmpTrans = new BitmapTransform(); bmpTrans.InterpolationMode = BitmapInterpolationMode.Cubic; /*BitmapBounds bounds = new BitmapBounds(); * bounds.X = 0; * bounds.Y = 0; * bounds.Height = 360; * bounds.Height = 360; * bmpTrans.Bounds = bounds;*/ bmpTrans.ScaledHeight = size; bmpTrans.ScaledWidth = size; PixelDataProvider pixelDataProvider = await frame.GetPixelDataAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, bmpTrans, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.ColorManageToSRgb); byte[] pixelData = pixelDataProvider.DetachPixelData(); InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream(); BitmapEncoder enc = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ras); // write the pixel data to our stream enc.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, size, size, bmpDecoder.DpiX, bmpDecoder.DpiY, pixelData); await enc.FlushAsync(); string fileName = Path.GetRandomFileName(); var file = await ApplicationData.Current.LocalFolder.CreateFileAsync( fileName + ".jpg", CreationCollisionOption.GenerateUniqueName); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await RandomAccessStream.CopyAndCloseAsync(ras.GetInputStreamAt(0), fileStream.GetOutputStreamAt(0)); } return(new Uri("ms-appdata:///local/" + file.Name)); } }