private async void openMyCamera() { CameraCaptureUI cameraUI = new CameraCaptureUI(); cameraUI.PhotoSettings.AllowCropping = false; cameraUI.PhotoSettings.MaxResolution = CameraCaptureUIMaxPhotoResolution.MediumXga; Windows.Storage.StorageFile capturedMedia = await cameraUI.CaptureFileAsync(CameraCaptureUIMode.Photo); if (capturedMedia != null) { using (var streamCamera = await capturedMedia.OpenAsync(FileAccessMode.Read)) { bitmapCamera = new BitmapImage(); bitmapCamera.SetSource(streamCamera); //To display the image in a XAML image object, do this: imagePreivew.Source = bitmapCamera; // Convert the camera bitap to a WriteableBitmap object, // which is often a more useful format. int width = bitmapCamera.PixelWidth; int height = bitmapCamera.PixelHeight; WriteableBitmap wBitmap = new WriteableBitmap(width, height); using (var stream = await capturedMedia.OpenAsync(FileAccessMode.Read)) { wBitmap.SetSource(stream); } SaveImageAsJpeg(wBitmap); } } }
/// <summary> /// Write the location metadata to the image file /// </summary> public async static Task WriteSurveyPhotoMetaData(StorageFile file, Geoposition pos, string surveyId = "") { using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(stream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(stream, decoder); // Write the gps data var propertySet = new BitmapPropertySet(); var latitudeNumerator = new BitmapTypedValue(CoordDoubleToIntArray(pos.Coordinate.Latitude), PropertyType.Int32Array); var latitudeRef = new BitmapTypedValue("N", PropertyType.String); var longitudeNumerator = new BitmapTypedValue(CoordDoubleToIntArray(pos.Coordinate.Longitude), PropertyType.Int32Array); var longitudeRef = new BitmapTypedValue("W", PropertyType.String); propertySet.Add("System.GPS.LatitudeNumerator", latitudeNumerator); propertySet.Add("System.GPS.LatitudeRef", latitudeRef); propertySet.Add("System.GPS.LatitudeDenominator", new BitmapTypedValue(new [] { 1, 1, 10000 }, PropertyType.Int32Array)); propertySet.Add("System.GPS.LongitudeNumerator", longitudeNumerator); propertySet.Add("System.GPS.LongitudeRef", longitudeRef); propertySet.Add("System.GPS.LongitudeDenominator", new BitmapTypedValue(new[] { 1, 1, 10000 }, PropertyType.Int32Array)); // Write the surveyId data if (!string.IsNullOrEmpty(surveyId)) { var surveyIdTyped = new BitmapTypedValue(surveyId, Windows.Foundation.PropertyType.String); propertySet.Add("System.Comment", surveyIdTyped); } await encoder.BitmapProperties.SetPropertiesAsync(propertySet); await encoder.FlushAsync(); } }
private async void Button_Click(object sender, RoutedEventArgs e) { /*参考文档: https://docs.microsoft.com/zh-cn/windows/uwp/files/quickstart-using-file-and-folder-pickers */ var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add("*"); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile imagefile = await storageFolder.CreateFileAsync("avatar", CreationCollisionOption.ReplaceExisting); imagefile = await picker.PickSingleFileAsync(); if (imagefile != null) //若选中了图片,则将该图片填充头像,并保存图像地址 { imgpath = imagefile.Path; localSettings.Containers[username.Text].Values["avatar"] = imgpath; ImageBrush brush = new ImageBrush(); BitmapImage bitmap = new BitmapImage(); using (var stream = await imagefile.OpenAsync(FileAccessMode.ReadWrite)) //需要使用文件流才能访问storagefile图片路径 { bitmap.SetSource(stream); } brush.ImageSource = bitmap; Avator.Fill = brush; } }
private async System.Threading.Tasks.Task pp_TappedAsync() { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { // Ensure the stream is disposed once the image is loaded using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { // Set the image source to the selected bitmap BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(fileStream); pp.ProfilePicture = bitmapImage; } } }
private async void Open_Click(object sender, RoutedEventArgs e) { open.IsChecked = false; Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker(); openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; openPicker.FileTypeFilter.Add(".gif"); Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync(); if (file != null) { Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); using (var inputStream = stream.GetInputStreamAt(0)) { await canvas.InkPresenter.StrokeContainer.LoadAsync(inputStream); } stream.Dispose(); alreadySaved = true; lastFile = file; } }
private async void ImagePiker_Click(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { // Application now has read/write access to the picked file IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read); BitmapImage bitmap = new BitmapImage(); bitmap.SetSource(stream); this.Picture.Source = bitmap; } else { this.Picture.Source = null; } }
private async void OpenShitBtn_Click(object sender, RoutedEventArgs e) { //выбор файла Windows.Storage.Pickers.FileOpenPicker open = new Windows.Storage.Pickers.FileOpenPicker(); open.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; open.FileTypeFilter.Add(".rtf"); // собсно открытие файла Windows.Storage.StorageFile file = await open.PickSingleFileAsync(); if (file != null)//не даст словить NRE и похожую дичь { using (Windows.Storage.Streams.IRandomAccessStream randAccStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { // грузит содержимое файла в нашу коробычку ShitEditor.Document.LoadFromStream(Windows.UI.Text.TextSetOptions.FormatRtf, randAccStream); } } else //если дичь таки произошла { Windows.UI.Popups.MessageDialog errorBox = new Windows.UI.Popups.MessageDialog("Начальника, всё сломався!"); await errorBox.ShowAsync(); } }
private async void UploadButton_Click(object sender, RoutedEventArgs e) { //do whatever you need. Canvas.SetZIndex(UploadGrid, 3); Canvas.SetZIndex(GoalGrid, 1); Canvas.SetZIndex(MapGrid, 1); Page_Title.Text = "Upload"; Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; try { Windows.Storage.StorageFile saveFile = await storageFolder.GetFileAsync("save.png"); var bitmap = new BitmapImage(new Uri(saveFile.Path)); var Stream = await saveFile.OpenAsync(Windows.Storage.FileAccessMode.Read); bitmap.SetSource(Stream); img.Source = bitmap; } catch (Exception) { } }
//We use a protected override void to execute code as soon as the page is loaded into memory protected async override void OnNavigatedTo(NavigationEventArgs e) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile signInInfo = await storageFolder.CreateFileAsync("signin.txt", Windows.Storage.CreationCollisionOption.OpenIfExists); var stream = await signInInfo.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); ulong size = stream.Size; using (var inputStream = stream.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(inputStream)) { uint numBytesLoaded = await dataReader.LoadAsync((uint)size); string signinAddress = dataReader.ReadString(numBytesLoaded); //string currentUser = emailBox.Text; if (signinAddress.ToString() == "") { emailBox.Text = "@wh-at.net"; } else { emailBox.Text = signinAddress.ToString(); Frame.Navigate(typeof(helpdesk)); } } } stream.Dispose(); }
async Task<RenderTargetBitmap> SaveToFileAsync(FrameworkElement uielement, StorageFile file) { if (file != null) { CachedFileManager.DeferUpdates(file); Guid encoderId = GetBitmapEncoder(file.FileType); try { using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { return await CaptureToStreamAsync(uielement, stream, encoderId); } } catch (Exception ex) { DisplayMessage(ex.Message); } var status = await CachedFileManager.CompleteUpdatesAsync(file); } return null; }
private async void filePick_Click(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary; picker.FileTypeFilter.Add(".mp3"); picker.FileTypeFilter.Add(".mp4"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); mediaElement.SetSource(stream, file.ContentType); mediaElement.Play(); mediaElement.AreTransportControlsEnabled = true; Debug.WriteLine("Playing: " + file.Name); } else { Debug.WriteLine("Operation cancelled."); } }
private async void LoadMedia() { Media media = this.ViewModel.StoryBoard.MediaSource as Media; Windows.Storage.StorageFile file = await Windows.Storage.StorageFile.GetFileFromPathAsync(media.SourcePath); if (file != null) { var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); MediaSource mediaSource = MediaSource.CreateFromStream(stream, file.ContentType); mediaSource.OpenOperationCompleted += MediaSource_OpenOperationCompleted; this._mediaPlayer.Source = mediaSource; this._mediaPlayer.CommandManager.IsEnabled = false; this._mediaPlayer.TimelineController = _mediaTimelineController; this._mediaPlayerElement.SetMediaPlayer(this._mediaPlayer); DispatcherTimer timer = new DispatcherTimer(); timer.Interval = TimeSpan.FromSeconds(1); timer.Tick += Timer_Tick; timer.Start(); timeLine.Value = _mediaTimelineController.Position.TotalSeconds; lowerTime.Text = GenTimeSpanFromSeconds(Math.Round(RangeSelectorControl.RangeMin)); upperTime.Text = GenTimeSpanFromSeconds(Math.Round(RangeSelectorControl.RangeMax)); } }
public static async Task OutputSensorDataAsync() { // ファイルの作成 すでに存在する場合は置き換える Windows.Storage.StorageFolder documentsLibrary = KnownFolders.DocumentsLibrary; Windows.Storage.StorageFile file = await documentsLibrary.CreateFileAsync(sensorDataFileName, Windows.Storage.CreationCollisionOption.ReplaceExisting); // ファイルへの書き込み var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); using (var outputStream = stream.GetOutputStreamAt(0)) { using (var dataWriter = new Windows.Storage.Streams.DataWriter(outputStream)) { dataWriter.WriteString("valueX valueY valueZ time\n"); if (Sensor_Values_Record_Time_List != null) { for (int i = 0; i < Sensor_Values_Record_Time_List.Count; i++) { dataWriter.WriteString($"{Math.Round(Sensor_ValueX_List[i], 3)} {Math.Round(Sensor_ValueY_List[i], 3)} {Math.Round(Sensor_ValueZ_List[i], 3)} {Math.Round(Sensor_Values_Record_Time_List[i], 2)}\n"); } } await dataWriter.StoreAsync(); await outputStream.FlushAsync(); } } stream.Dispose(); // Or use the stream variable (see previous code snippet) with a using statement as well. }
/// <summary> /// Triggered when the Capture Photo button is clicked by the user /// </summary> private async void Capture_Click(object sender, RoutedEventArgs e) { // Hide the capture photo button CaptureButton.Visibility = Visibility.Collapsed; // Capture current frame from webcam, store it in temporary storage and set the source of a BitmapImage to said photo currentIdPhotoFile = await webcam.CapturePhoto(); var photoStream = await currentIdPhotoFile.OpenAsync(FileAccessMode.ReadWrite); BitmapImage idPhotoImage = new BitmapImage(); await idPhotoImage.SetSourceAsync(photoStream); // Set the soruce of the photo control the new BitmapImage and make the photo control visible IdPhotoControl.Source = idPhotoImage; IdPhotoControl.Visibility = Visibility.Visible; // Collapse the webcam feed or disabled feed grid. Make the enter user name grid visible. WebcamFeed.Visibility = Visibility.Collapsed; DisabledFeedGrid.Visibility = Visibility.Collapsed; UserNameGrid.Visibility = Visibility.Visible; // Dispose photo stream photoStream.Dispose(); }
private async void SelectPicture(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); BitmapImage bitmapImage = new BitmapImage(); bitmapImage.DecodePixelWidth = 350; bitmapImage.DecodePixelHeight = 180; await bitmapImage.SetSourceAsync(fileStream); background.Source = bitmapImage; } }
async void OnSaveAsync(object sender, RoutedEventArgs e) { // We don't want to save an empty file if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count > 0) { var savePicker = new Windows.Storage.Pickers.FileSavePicker(); savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; savePicker.FileTypeChoices.Add("Gif with embedded ISF", new System.Collections.Generic.List <string> { ".gif" }); Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync(); if (null != file) { try { using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream); } rootPage.NotifyUser(inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count + " stroke(s) saved!", NotifyType.StatusMessage); } catch (Exception ex) { rootPage.NotifyUser(ex.Message, NotifyType.ErrorMessage); } } } else { rootPage.NotifyUser("There is no ink to save.", NotifyType.ErrorMessage); } }
/// <summary> /// This function would display the Image /// </summary> public async Task DisplayImageFileAsync(StorageFile file) { // Display the image in the UI. BitmapImage src = new BitmapImage(); src.SetSource(await file.OpenAsync(FileAccessMode.Read)); Image1.Source = src; }
public async void selectPic(Image pic) { var fop = new FileOpenPicker(); fop.ViewMode = PickerViewMode.Thumbnail; fop.SuggestedStartLocation = PickerLocationId.PicturesLibrary; fop.FileTypeFilter.Add(".jpg"); fop.FileTypeFilter.Add(".jpeg"); fop.FileTypeFilter.Add(".png"); fop.FileTypeFilter.Add(".gif"); Windows.Storage.StorageFile file = await fop.PickSingleFileAsync(); try { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapImage bitmapImage = new BitmapImage(); await bitmapImage.SetSourceAsync(fileStream); pic.Source = bitmapImage; imgName = file.Path.Substring(file.Path.LastIndexOf('\\') + 1); await file.CopyAsync(ApplicationData.Current.LocalFolder, imgName, NameCollisionOption.ReplaceExisting); Debug.WriteLine(imgName); } } catch (Exception) { return; } }
/// <summary> /// Saves the specified bitmap to the specified location. /// </summary> /// <param name="source">The source bitmap image.</param> /// <param name="destination">The destination storage file for the image. JPEG, PNG, GIF, BMP and TIFF formats are supported.</param> /// <param name="width">The width of the image file.</param> /// <param name="height">The height of the image file.</param> /// <returns>True if the bitmap file was successfully saved. False otherwise.</returns> public async Task<bool> Save(WriteableBitmap source, StorageFile destination, int width, int height) { if (source == null || destination == null) return false; try { Guid encoderID = GetEncoderId(destination); using (IRandomAccessStream stream = await destination.OpenAsync(FileAccessMode.ReadWrite)) { Stream pixelStream = source.PixelBuffer.AsStream(); byte[] pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0, pixels.Length); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(encoderID, stream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)source.PixelWidth, (uint)source.PixelHeight, Constants.DPI, Constants.DPI, pixels); if (source.PixelWidth != width || source.PixelHeight != height) { encoder.BitmapTransform.ScaledWidth = (uint)width; encoder.BitmapTransform.ScaledHeight = (uint)height; } await encoder.FlushAsync(); } return true; } catch (Exception ex) { Debug.WriteLine(ex.Message); } return false; }
async Task saveDebugImage(SoftwareBitmap bitmap, IList <PredictionModel> result) { WriteableBitmap newImage = new WriteableBitmap(bitmap.PixelWidth, bitmap.PixelHeight); bitmap.CopyToBuffer(newImage.PixelBuffer); for (int predictIdx = 0; predictIdx < result.Count; predictIdx++) { PredictionModel predictInfo = result[predictIdx]; newImage.DrawRectangle((int)predictInfo.BoundingBox.Left * bitmap.PixelWidth, (int)predictInfo.BoundingBox.Top * bitmap.PixelHeight, (int)predictInfo.BoundingBox.Width * bitmap.PixelWidth, (int)predictInfo.BoundingBox.Height * bitmap.PixelHeight, Colors.Red); } Windows.Storage.StorageFile testFile = await folder.CreateFileAsync("test.jpg", Windows.Storage.CreationCollisionOption.ReplaceExisting); using (IRandomAccessStream stream = await testFile.OpenAsync(FileAccessMode.ReadWrite)) { Guid BitmapEncoderGuid = BitmapEncoder.JpegEncoderId; BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoderGuid, stream); Stream pixelStream = newImage.PixelBuffer.AsStream(); byte[] pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0, pixels.Length); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)newImage.PixelWidth, (uint)newImage.PixelHeight, 96.0, 96.0, pixels); await encoder.FlushAsync(); } }
private async void selectPhoto(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read)) { BitmapImage bitmapImage = new BitmapImage(); bitmapImage.DecodePixelWidth = 353; await bitmapImage.SetSourceAsync(fileStream); userFace.Source = bitmapImage; var fileToSave = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("temp.png", CreationCollisionOption.ReplaceExisting); var stream = await file.OpenReadAsync(); var bytes = await Temp.GetBytesFromStream(stream); await FileIO.WriteBytesAsync(fileToSave, bytes); } } }
private async void Button_Click(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { // Application now has read/write access to the picked file this.textblock.Text = "Picked photo: " + file.Name; var stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); image.SetSource(stream); imageView.Source = image; } else { this.textblock.Text = "Operation cancelled."; } }
async void PickFile(object sender, RoutedEventArgs e) { var currentState = Windows.UI.ViewManagement.ApplicationView.Value; if (currentState == Windows.UI.ViewManagement.ApplicationViewState.Snapped && !Windows.UI.ViewManagement.ApplicationView.TryUnsnap()) { TranscodeError("Cannot pick files while application is in snapped view"); } else { Windows.Storage.Pickers.FileOpenPicker picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary; picker.FileTypeFilter.Add(".wmv"); picker.FileTypeFilter.Add(".mp4"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { Windows.Storage.Streams.IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); _InputFile = file; InputVideo.SetSource(stream, file.ContentType); InputVideo.Play(); // Enable buttons EnableButtons(); } } }
public async static Task<BitmapImage> GetImageAsync(StorageFile storageFile) { BitmapImage bitmapImage = new BitmapImage(); FileRandomAccessStream stream = (FileRandomAccessStream)await storageFile.OpenAsync(FileAccessMode.Read); bitmapImage.SetSource(stream); return bitmapImage; }
private async void OnDeferredImageRequestedHandler(DataProviderRequest providerRequest, StorageFile imageFile) { // In this delegate we provide updated Bitmap data using delayed rendering. if (imageFile != null) { // If the delegate is calling any asynchronous operations it needs to acquire the deferral first. This lets the // system know that you are performing some operations that might take a little longer and that the call to // SetData could happen after the delegate returns. Once you acquired the deferral object you must call Complete // on it after your final call to SetData. DataProviderDeferral deferral = providerRequest.GetDeferral(); InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream(); // Make sure to always call Complete when done with the deferral. try { // Decode the image and re-encode it at 50% width and height. IRandomAccessStream imageStream = await imageFile.OpenAsync(FileAccessMode.Read); BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream); BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder); imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5); imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5); await imageEncoder.FlushAsync(); providerRequest.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream)); } finally { deferral.Complete(); } } }
private async void btnSeleccionarImagen_Click(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop; picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { // Application now has read/write access to the picked file URLImage = file.Name; using (var randomAccessStream = await file.OpenAsync(FileAccessMode.Read)) { var result = new BitmapImage(); await result.SetSourceAsync(randomAccessStream); imgPueblo.Source = result; } } else { } }
protected GameViewModel() : base() { CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { MediaPlayer = new MediaElement(); }); lock (locker) { if (StopwatchFile == null || AlarmFile == null) { LoadFileTask = Task.Run(async () => { StorageFolder folder = await (await Package.Current.InstalledLocation.GetFolderAsync("Assets")).GetFolderAsync("Sounds"); StopwatchFile = await folder.GetFileAsync("Stopwatch.wav"); AlarmFile = await folder.GetFileAsync("Alarm.wav"); CheerFile = await folder.GetFileAsync("Cheer.wav"); AwwFile = await folder.GetFileAsync("Aww.wav"); VictoryFile = await folder.GetFileAsync("Victory.wav"); (await StopwatchFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(StopwatchStream); (await AlarmFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(AlarmStream); (await CheerFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(CheerStream); (await AwwFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(AwwStream); (await VictoryFile.OpenAsync(FileAccessMode.Read)).AsStream().CopyTo(VictoryStream); }); } } }
private async Task<BitmapImage> LoadImage(StorageFile file) { var image = new BitmapImage(); FileRandomAccessStream stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read); image.SetSource(stream); return image; }
private async void MenuFlyoutItem_Click_7(object sender, RoutedEventArgs e) { Windows.Storage.Pickers.FileOpenPicker open = new Windows.Storage.Pickers.FileOpenPicker(); open.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; open.FileTypeFilter.Add(".rtf"); Windows.Storage.StorageFile file = await open.PickSingleFileAsync(); if (file != null) { try { Windows.Storage.Streams.IRandomAccessStream randAccStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); flextextwrite.Document.LoadFromStream(Windows.UI.Text.TextSetOptions.FormatRtf, randAccStream); } catch (Exception) { ContentDialog errorDialog = new ContentDialog() { Title = "File open error", Content = "Sorry, I couldn't open the file.", PrimaryButtonText = "Ok" }; await errorDialog.ShowAsync(); } } }
private async Task GetFileReference() { if (SaveSerialToggleButton.IsChecked.GetValueOrDefault()) { try { file = await StorageApplicationPermissions.FutureAccessList.GetFileAsync("Default"); await file.OpenAsync(FileAccessMode.ReadWrite); } catch { } if (file == null) { var savePicker = new Windows.Storage.Pickers.FileSavePicker(); savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; // Dropdown of file types the user can save the file as savePicker.FileTypeChoices.Add("Plain Text", new List <string>() { ".txt" }); // Default file name if the user does not type one in or select a file to replace savePicker.SuggestedFileName = "705SerialData"; file = await savePicker.PickSaveFileAsync(); StorageApplicationPermissions.FutureAccessList.AddOrReplace("Default", file); } } }
private async void Open_Click(object sender, RoutedEventArgs e) { //文件选择器 FileOpenPicker openPicker = new FileOpenPicker(); //初始位置 openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; //添加文件类型 openPicker.FileTypeFilter.Add(".jpg"); openPicker.FileTypeFilter.Add(".jpeg"); openPicker.FileTypeFilter.Add(".png"); openPicker.FileTypeFilter.Add(".gif"); //选取单个文件 Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync(); if (file != null) { using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read)) { var srcImage = new BitmapImage(); await srcImage.SetSourceAsync(stream); Img.Source = srcImage; } } }
private async Task<Uri> SaveToFile(StorageFile file) { Uri uri = null; if (inkCanvas.InkPresenter.StrokeContainer.GetStrokes().Count > 0) { try { using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(stream); uri = new Uri("ms-appdata:///local/" + file.Name); } } catch (Exception ex) { if (Debugger.IsAttached) { Debugger.Break(); } } } return uri; }
private async void RenderInkImageAsync() { IReadOnlyList <InkStroke> currentStrokes = inkCanvas.InkPresenter.StrokeContainer.GetStrokes(); if (currentStrokes.Count > 0) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.TemporaryFolder; Windows.Storage.StorageFile file = await storageFolder.CreateFileAsync($"{Guid.NewGuid()}.png", Windows.Storage.CreationCollisionOption.ReplaceExisting); if (file != null) { Windows.Storage.CachedFileManager.DeferUpdates(file); IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite); using (IOutputStream outputStream = stream.GetOutputStreamAt(0)) { await inkCanvas.InkPresenter.StrokeContainer.SaveAsync(outputStream); await outputStream.FlushAsync(); } stream.Dispose(); } BitmapImage bm = new BitmapImage(new Uri($"ms-appdata:///temp/{file.Name}")); App.ViewModel.SelectedDocument.AnnotationImage = bm; } Frame.GoBack(); }
public async System.Threading.Tasks.Task saveImageAsync() { Stream pixelStream = this.bitmap1.PixelBuffer.AsStream(); byte[] pixels = new byte[pixelStream.Length]; await pixelStream.ReadAsync(pixels, 0, pixels.Length); var savePicker = new Windows.Storage.Pickers.FileSavePicker(); savePicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; // dropdown menu of file types the user can save the file as savePicker.FileTypeChoices.Add("PNG", new List <string>() { ".png" }); // default file name if the user does not type one in or select a file to replace savePicker.SuggestedFileName = "IR_Capture"; Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync(); if (file != null) { IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)bitmap1.PixelWidth, (uint)bitmap1.PixelHeight, 96.0, 96.0, pixels); await encoder.FlushAsync(); } }
private async void UploadImage_OnClick(object sender, TappedRoutedEventArgs e) { // Opening the file explorer var picker = new Windows.Storage.Pickers.FileOpenPicker { ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail, SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary }; picker.FileTypeFilter.Add(".jpg"); picker.FileTypeFilter.Add(".jpeg"); picker.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { // Application now has read/write access to the picked file using (var fileStream = await file.OpenAsync(FileAccessMode.Read)) { await ImgurApi.UploadImage(fileStream, _user); } } else { // cancell action } }
/// <summary> /// 通过FilePicker获取富文本流(弹出框选文件) /// </summary> /// <returns>富文本流</returns> public async Task <IRandomAccessStream> GetRandomAccessStream() { Windows.Storage.Pickers.FileOpenPicker open = new Windows.Storage.Pickers.FileOpenPicker(); open.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; open.FileTypeFilter.Add(".rtf"); Windows.Storage.StorageFile file = await open.PickSingleFileAsync(); if (file != null) { try { Windows.Storage.Streams.IRandomAccessStream randAccStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); // Load the file into the Document property of the RichEditBox. return(randAccStream); } catch (Exception) { ContentDialog errorDialog = new ContentDialog() { Title = "File open error", Content = "Sorry, I couldn't open the file.", PrimaryButtonText = "Ok" }; await errorDialog.ShowAsync(); } } return(null); }
// Import board from GIF private async void importBoard(object sender, RoutedEventArgs e) { // Let users choose their ink file using a file picker. // Initialize the picker. Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker(); openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; openPicker.FileTypeFilter.Add(".gif"); // Show the file picker. Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync(); // User selects a file and picker returns a reference to the selected file. if (file != null) { // Open a file stream for reading. IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); // Read from file. using (var inputStream = stream.GetInputStreamAt(0)) { await inkCanvas.InkPresenter.StrokeContainer.LoadAsync(inputStream); } stream.Dispose(); } // User selects Cancel and picker returns null. else { // Operation cancelled. } }
private async void buttonSelectSong_Click(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.List; picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.MusicLibrary; picker.FileTypeFilter.Add(".mp3"); picker.FileTypeFilter.Add(".wav"); selectedSongFile = await picker.PickSingleFileAsync(); if (selectedSongFile != null) { // Application now has read/write access to the picked file textBoxSelectedSong.Text = selectedSongFile.Path; //String path = "C:\\Users\\Venaca\\Music\\Písničky všechny\\Tancování\\10 letkiss---Letkiss.mp3"; // Windows.Storage.StorageFile selectedSongFile = StorageFile.GetFileFromPathAsync(path).GetResults(); var stream = await selectedSongFile.OpenAsync(Windows.Storage.FileAccessMode.Read); player.SetSource(stream, ""); } else { textBoxSelectedSong.Text = ""; } }
private async void BtnOpen_Click(object sender, RoutedEventArgs e) { InkStrokeContainer container = new InkStrokeContainer(); Windows.Storage.Pickers.FileOpenPicker openPicker = new Windows.Storage.Pickers.FileOpenPicker(); openPicker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary; openPicker.FileTypeFilter.Add(".gif"); Windows.Storage.StorageFile file = await openPicker.PickSingleFileAsync(); if (file != null) { IRandomAccessStream stream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); using (var inputStream = stream.GetInputStreamAt(0)) { await container.LoadAsync(inputStream); } stream.Dispose(); _inkStrokes.Clear(); _inkStrokes.Add(container); DrawingCanvas.Invalidate(); } else { } }
private async void seleccionarImagen(object sender, RoutedEventArgs e) { FileOpenPicker picker = new FileOpenPicker(); picker.SuggestedStartLocation = PickerLocationId.PicturesLibrary; picker.FileTypeFilter.Add(".png"); file = await picker.PickSingleFileAsync(); BitmapImage image = new BitmapImage(); try { using (var stream = await file.OpenAsync(FileAccessMode.Read)) { await image.SetSourceAsync(stream); } ImageBrush brush = new ImageBrush(); brush.Stretch = Stretch.UniformToFill; brush.ImageSource = image; imagen.Fill = brush; } catch (Exception exception) { } }
public static async Task<Color> GetDominantColorFromFile(StorageFile file) { //get the file using (var stream = await file.OpenAsync(FileAccessMode.Read)) { //Create a decoder for the image var decoder = await BitmapDecoder.CreateAsync(stream); //Create a transform to get a 1x1 image var myTransform = new BitmapTransform { ScaledHeight = 1, ScaledWidth = 1 }; //Get the pixel provider var pixels = await decoder.GetPixelDataAsync( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, myTransform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); //Get the bytes of the 1x1 scaled image var bytes = pixels.DetachPixelData(); //read the color var myDominantColor = Color.FromArgb(255, bytes[0], bytes[1], bytes[2]); return myDominantColor; } }
public async void PrintPDF(Memo memo) { Reports = new Reports(memo); //var stream = new InMemoryRandomAccessStream(); //FileSavePicker fileSavePicker = new FileSavePicker(); WriterFormat format = WriterFormat.PDF; //fileSavePicker.SuggestedFileName = "ExportReport"; //var savedItem = await fileSavePicker.PickSaveFileAsync(); //if (savedItem != null) // Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile savedItem = await storageFolder.CreateFileAsync("sample.pdf", Windows.Storage.CreationCollisionOption.ReplaceExisting); //var savedItem = await FileSavePicker.PickSaveFileAsync(); MemoryStream exportFileStream = new MemoryStream(); Assembly assembly = typeof(HomePage).GetTypeInfo().Assembly; // Ensure the report loaction and application name. Stream reportStream = assembly.GetManifestResourceStream("UwpApp.Report.Inv.rdlc"); BoldReports.UI.Xaml.ReportDataSourceCollection datas = new BoldReports.UI.Xaml.ReportDataSourceCollection(); datas.Add(new BoldReports.UI.Xaml.ReportDataSource { Name = "PatientInfo", Value = Reports.LoadReport() }); datas.Add(new BoldReports.UI.Xaml.ReportDataSource { Name = "MemoDetails", Value = Reports.loadmemodetail() }); ReportWriter writer = new ReportWriter(reportStream, datas); writer.ExportMode = ExportMode.Local; await writer.SaveASync(exportFileStream, format); try { using (IRandomAccessStream stream = await savedItem.OpenAsync(FileAccessMode.ReadWrite)) { // Write compressed data from memory to file using (Stream outstream = stream.AsStreamForWrite()) { byte[] buffer = exportFileStream.ToArray(); outstream.Write(buffer, 0, buffer.Length); outstream.Flush(); } } exportFileStream.Dispose(); } catch { } }
/// <summary> /// Metode for å gjøre om fil til bilde. /// </summary> private async Task<BitmapImage> GetBitmapImageAsync(StorageFile storageFile) { var bitmapImage = new BitmapImage(); IAsyncOperation<IRandomAccessStream> operation = storageFile.OpenAsync(FileAccessMode.Read); IRandomAccessStream stream = await operation; bitmapImage.SetSource(stream); return bitmapImage; }
public static async Task<string> ToBase64(StorageFile bitmap) { var stream = await bitmap.OpenAsync(FileAccessMode.Read); var decoder = await BitmapDecoder.CreateAsync(stream); var pixels = await decoder.GetPixelDataAsync(); var bytes = pixels.DetachPixelData(); return await ToBase64(bytes, decoder.PixelWidth, decoder.PixelHeight, decoder.DpiX, decoder.DpiY); }
public static async Task<string> EncodeFromStorageFile(StorageFile bitmap) { var stream = await bitmap.OpenAsync(Windows.Storage.FileAccessMode.Read); var decoder = await BitmapDecoder.CreateAsync(stream); var pixels = await decoder.GetPixelDataAsync(); var bytes = pixels.DetachPixelData(); return await EncodeFromByte(bytes, (uint)decoder.PixelWidth, (uint)decoder.PixelHeight, decoder.DpiX, decoder.DpiY); }
static async public Task<BitmapImage> GetImage(StorageFile file) { IRandomAccessStream photoStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read); BitmapImage bmpimg = new BitmapImage(); bmpimg.SetSource(photoStream); return bmpimg; }
public async void UploadFileAsync(StorageFile file) { var fileContent = await file.OpenAsync(FileAccessMode.Read); HttpStreamContent fileStream = new HttpStreamContent(fileContent); HttpMultipartFormDataContent formData = new HttpMultipartFormDataContent { { fileStream, "file", file.Path } }; var asyncOperation = BoxHttpClient.PostAsync(new Uri(BoxUploadUrl), formData); int index = UploadFileList.AddEntry(file, DateTime.Now, asyncOperation); UploadFileList[index].StartUpload(); }
public async Task<WriteableBitmap> RetrieveAndPutBitmapAsync(StorageFile file) { IRandomAccessStream contents = await file.OpenAsync(FileAccessMode.Read); WriteableBitmap bitmap = new WriteableBitmap(100, 100); bitmap.SetSource(contents); _cache.Add(new BitmapCacheItem() { StorageFile = file, Bitmap = bitmap }); Debug.WriteLine("Caching bitmap for file: " + file.Path + "::" + file.Name); return bitmap; }
public async Task TakeScreenshotAsync(FrameworkElement element, StorageFile file) { CachedFileManager.DeferUpdates(file); using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) { await CaptureToStreamAsync(element, stream, BitmapEncoder.PngEncoderId); } await CachedFileManager.CompleteUpdatesAsync(file); }
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 async Task<byte[]> GetPhotoBytesAsync(StorageFile file) { IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read); var reader = new Windows.Storage.Streams.DataReader(fileStream.GetInputStreamAt(0)); await reader.LoadAsync((uint)fileStream.Size); byte[] pixels = new byte[fileStream.Size]; reader.ReadBytes(pixels); return pixels; }
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(); }
private static async Task<BitmapImage> CarregarImagem(StorageFile arquivo) { BitmapImage bitmapImage = new BitmapImage(); FileRandomAccessStream stream = (FileRandomAccessStream)await arquivo.OpenAsync(FileAccessMode.Read); bitmapImage.SetSource(stream); return bitmapImage; }
private async void LoadThumbnail(StorageFile file) { var image = new BitmapImage(); image.DecodePixelHeight = 72; using (var stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read)) { await image.SetSourceAsync(stream); } Image = image; }
private async Task<uint> OpenFile(string fileName) { StorageFolder myStorageFolder = KnownFolders.DocumentsLibrary; myFile = await myStorageFolder.GetFileAsync("ECHelper Files\\" + fileName+".ech"); readStream = await myFile.OpenAsync(FileAccessMode.Read); fileReader = new DataReader(readStream); count = await fileReader.LoadAsync((uint)readStream.Size); data = new byte[count]; fileReader.ReadBytes(data); return count; }
public static async Task<WriteableBitmap> GetPictureAsync(StorageFile ImageFile) { using (IRandomAccessStream stream = await ImageFile.OpenAsync(FileAccessMode.Read)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); WriteableBitmap bmp = new WriteableBitmap((int)decoder.PixelWidth, (int)decoder.PixelHeight); await bmp.SetSourceAsync(stream); return bmp; } }
private async Task LoadImage(StorageFile file) { ImageProperties imgProp = await file.Properties.GetImagePropertiesAsync(); using (var imgStream = await file.OpenAsync(FileAccessMode.Read)) { bitmap = new WriteableBitmap((int)imgProp.Width, (int)imgProp.Height); bitmap.SetSource(imgStream); PreviewImage.Source = bitmap; } }
private async Task<BitmapImage> LoadImage(StorageFile file) { BitmapImage bitmapImage = new BitmapImage(); // Create a stream to display the file FileRandomAccessStream stream = (FileRandomAccessStream)await file.OpenAsync(FileAccessMode.Read); // Set the stream bitmapImage.SetSource(stream); return bitmapImage; }
public static async Task<WriteableBitmap> LoadImage(StorageFile file) { ImageProperties imgProp = await file.Properties.GetImagePropertiesAsync(); using (var imgStream = await file.OpenAsync(FileAccessMode.Read)) { WriteableBitmap writeablebitmap = new WriteableBitmap((int)imgProp.Width, (int)imgProp.Height); writeablebitmap.SetSource(imgStream); return writeablebitmap; } }
public static async Task<SoftwareBitmap> StorageFileToSoftwareBitmap(StorageFile file) { if (file == null) return null; using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read)) { // Create the decoder from the stream BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); // Get the SoftwareBitmap representation of the file SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied); return softwareBitmap; } }