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 async Task AddFile(Action <ExpensesMobile.Models.File> postAction) { 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"); picker.FileTypeFilter.Add(".pdf"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); var f = await file.OpenReadAsync(); var stream = f.AsStream(); var mStream = new MemoryStream(); stream.CopyTo(mStream); postAction(new ExpensesMobile.Models.File { Name = file.Name, Bytes = mStream.ToArray(), Size = mStream.Length }); }
public async void LoadData(IEnumerable<XElement> sprites, StorageFile spriteSheetFile, string appExtensionId) { var bitmapImage = new BitmapImage(); using (var stream = await spriteSheetFile.OpenReadAsync()) { await bitmapImage.SetSourceAsync(stream); } //xaml List<ImageListItem> listOfImages = new List<ImageListItem>(); foreach (var sprite in sprites) { var row = int.Parse(sprite.Attributes("Row").First().Value); var col = int.Parse(sprite.Attributes("Column").First().Value); var brush = new ImageBrush(); brush.ImageSource = bitmapImage; brush.Stretch = Stretch.UniformToFill; brush.AlignmentX = AlignmentX.Left; brush.AlignmentY = AlignmentY.Top; brush.Transform = new CompositeTransform() { ScaleX = 2.35, ScaleY = 2.35, TranslateX = col * (-140), TranslateY = row * (-87) }; listOfImages.Add(new ImageListItem() { Title = sprite.Attributes("Title").First().Value, SpriteSheetBrush = brush, File = sprite.Attributes("File").First().Value, AppExtensionId = appExtensionId }); } lbPictures.ItemsSource = listOfImages; }
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); } } }
//Button to add an Image to the document private async void imgbtn_Click(object sender, RoutedEventArgs e) { Windows.Storage.Pickers.FileOpenPicker open = new Windows.Storage.Pickers.FileOpenPicker(); open.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.PicturesLibrary; open.FileTypeFilter.Add(".jpg"); open.FileTypeFilter.Add(".png"); Windows.Storage.StorageFile file = await open.PickSingleFileAsync(); if (file != null) { try { using (IRandomAccessStream imagestram = await file.OpenReadAsync()) { BitmapImage image = new BitmapImage(); await image.SetSourceAsync(imagestram); editBox.Document.Selection.InsertImage(image.PixelWidth, image.PixelHeight, 0, Windows.UI.Text.VerticalCharacterAlignment.Baseline, "Image", imagestram); } } catch (Exception) { ContentDialog errorDialog = new ContentDialog() { Title = "File open error", Content = "Sorry, I couldn't open the file.", PrimaryButtonText = "Ok" }; await errorDialog.ShowAsync(); } } }
private static async Task<SoftwareBitmapSource> CropPhoto(StorageFile photo, FaceRectangle rectangle) { using (var imageStream = await photo.OpenReadAsync()) { var decoder = await BitmapDecoder.CreateAsync(imageStream); if (decoder.PixelWidth >= rectangle.Left + rectangle.Width || decoder.PixelHeight >= rectangle.Top + rectangle.Height) { var transform = new BitmapTransform { Bounds = new BitmapBounds { X = (uint)rectangle.Left, Y = (uint)rectangle.Top, Height = (uint)rectangle.Height, Width = (uint)rectangle.Width } }; var softwareBitmapBGR8 = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource(); await bitmapSource.SetBitmapAsync(softwareBitmapBGR8); return bitmapSource; } return null; } }
private async Task<WriteableBitmap> CreateBitmapAsync(StorageFile file) { // デコード後の画像のサイズを格納する int width, height; // デコード後のピクセルデータを格納する var bytes = default(byte[]); // ファイルストリームを開きます using (var stream = await file.OpenReadAsync()) { // 非同期で新しいデコーダーを生成する var decoder = await BitmapDecoder.CreateAsync(stream); // 幅と高さを取得する width = (int)decoder.PixelWidth; height = (int)decoder.PixelHeight; // デコード後のピクセルデータを取得する var pixelData = await decoder.GetPixelDataAsync(); bytes = pixelData.DetachPixelData(); } // WriteableBitmapオブジェクトを生成し、デコード済みのピクセルデータを上書きする var bitmap = new WriteableBitmap(width, height); using (var pixelStream = bitmap.PixelBuffer.AsStream()) { await pixelStream.WriteAsync(bytes, 0, bytes.Length); } return bitmap; }
public async Task<RecipeBox> GetData() { if (await DoesFileExistAsync(FileName)) { file = await ApplicationData.Current.LocalFolder.CreateFileAsync(FileName, CreationCollisionOption.OpenIfExists); IInputStream sessionInputStream = await file.OpenReadAsync(); //Using DataContractSerializer , look at the cat-class // var sessionSerializer = new DataContractSerializer(typeof(List<object>), new Type[] { typeof(T) }); //_data = (List<object>)sessionSerializer.ReadObject(sessionInputStream.AsStreamForRead()); var serializer = new XmlSerializer(typeof(RecipeBox)); var rb =(RecipeBox)serializer.Deserialize(sessionInputStream.AsStreamForRead()); sessionInputStream.Dispose(); return rb; } else { var rb = generateDefault(); return rb; } }
public async static Task<bool> DetectSignature(StorageFile file, int corner) { bool success = false; try { var randomAccessStream = await file.OpenReadAsync(); var readStream = randomAccessStream.AsStreamForRead(); byte[] fileBytes = new byte[readStream.Length]; await readStream.ReadAsync(fileBytes,0,fileBytes.Length); StringBuilder serializedBytes = new StringBuilder(); fileBytes.ToList().ForEach(x => serializedBytes.AppendFormat("{0}.", Convert.ToUInt32(x))); string postParameters = String.Format("fileBytes={0}&fileName={1}", serializedBytes.ToString(), file.Name); byte[] postData = Encoding.UTF8.GetBytes(postParameters); HttpWebRequest req = CreateWebRequest("/Detection/MobileDetectMark"); var stream = await req.GetRequestStreamAsync(); await stream.WriteAsync(postData, 0, postData.Length); stream.Dispose(); HttpWebResponse result = (HttpWebResponse) await req.GetResponseAsync(); if (result.StatusCode == HttpStatusCode.OK && result.Cookies["user"] != null && result.Cookies["imageNumber"] != null) { PageData.Instance().SetDetectionResultsPageData(result.Cookies["user"].Value, int.Parse(result.Cookies["imageNumber"].Value)); success = true; } } catch (Exception E) { Popup errorPopup = new Popup(); } return success; }
//------------------------------------------------------------------------------- #region +OpenCheckList チェックリストを開く //------------------------------------------------------------------------------- // public async Task<bool> OpenCheckList(StorageFile file, Func<char, Task<int>> dayToDayIndexFunc, Func<int, Task<ComiketCircleAndLayout>> updateIdToCircle) { string enc_str = null; using (var str = await file.OpenReadAsync()) using (StreamReader sr = new StreamReader(str.AsStreamForRead())) { string line = sr.ReadLine(); enc_str = CheckList.CheckEncode(line); if (enc_str == null) { return false; } int comiketNo = CheckList.CheckComiketNo(line); if (comiketNo != _comiketNo) { return false; } } Encoding enc = Encoding.GetEncoding(enc_str); bool res; using (var str = await file.OpenReadAsync()) using (StreamReader sr = new StreamReader(str.AsStreamForRead(), enc)) { var lines = CheckList.FileReadLine(sr); res = await this.ReadCSV(lines, dayToDayIndexFunc, updateIdToCircle); } if (res) { await this.ReadTimeFile(); } return res; }
public static async Task ResizeImageUniformAsync(StorageFile sourceFile, StorageFile targetFile, int maxWidth = Int32.MaxValue, int maxHeight = Int32.MaxValue) { using (var stream = await sourceFile.OpenReadAsync()) { var decoder = await BitmapDecoder.CreateAsync(stream); if (IsGifImage(decoder)) { await sourceFile.CopyAndReplaceAsync(targetFile); return; } maxWidth = Math.Min(maxWidth, (int)decoder.OrientedPixelWidth); maxHeight = Math.Min(maxHeight, (int)decoder.OrientedPixelHeight); var imageSize = new Size(decoder.OrientedPixelWidth, decoder.OrientedPixelHeight); var finalSize = imageSize.ToUniform(new Size(maxWidth, maxHeight)); if (finalSize.Width == decoder.OrientedPixelWidth && finalSize.Height == decoder.OrientedPixelHeight) { await sourceFile.CopyAndReplaceAsync(targetFile); return; } await ResizeImageAsync(decoder, targetFile, finalSize); } }
private async void OpenImageFolder(object sender, RoutedEventArgs e) { //imgpicker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; //imgpicker.FileTypeFilter.Add(".jpg"); //imgpicker.FileTypeFilter.Add(".jpeg"); //imgpicker.FileTypeFilter.Add(".png"); //imgpicker.FileTypeFilter.Add(".bmp"); //imgpicker.FileTypeFilter.Add(".gif"); //imagefile = await imgpicker.PickSingleFileAsync(); //if (imagefile == null) return; //Tot.Text = imagefile.ContentType.ToString(); //if (imagefile == null) return; //IRandomAccessStream inputstream = await imagefile.OpenReadAsync(); //ImageProperties imageProperties = await imagefile.Properties.GetImagePropertiesAsync(); //BitmapImage bitmap = new BitmapImage(); //bitmap.SetSource(inputstream); //ImagePlace.Source = bitmap; btnOpn.IsEnabled = false; imgfpik.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; imgfpik.FileTypeFilter.Add(".jpg"); imgfpik.FileTypeFilter.Add(".jpeg"); imgfpik.FileTypeFilter.Add(".png"); imgfpik.FileTypeFilter.Add(".bmp"); imagefolder = await imgfpik.PickSingleFolderAsync(); if (imagefolder == null) { btnOpn.IsEnabled = true; return; } imgfiles = await imagefolder.GetFilesAsync(); if (imgfiles.Count < 1) { btnOpn.IsEnabled = true; return; } int rankey = ran.Next(0, imgfiles.Count); imagefile = imgfiles.ElementAt <StorageFile>(rankey); if (imagefile == null) { return; } Tot.Text = imagefile.ContentType.ToString(); if (imagefile == null) { return; } inputstream = await imagefile.OpenReadAsync(); ImageProperties imageProperties = await imagefile.Properties.GetImagePropertiesAsync(); horbitmap.SetSource(inputstream); HorImagePlace.Source = horbitmap; btnSat.IsEnabled = true; VerImagePlace.Visibility = Visibility.Collapsed; }
public static async Task<BitmapImage> SetSourceAsync(this BitmapImage bitmap, StorageFile file) { using (var stream = await file.OpenReadAsync()) { await bitmap.SetSourceAsync(stream); } return bitmap; }
/// <summary> /// Uploads an activity. /// </summary> /// <param name="file">The path to the activity file on your local hard disk.</param> /// <param name="dataFormat">The format of the file.</param> /// <param name="activityType">The type of the activity.</param> /// <returns>The status of the upload.</returns> public async Task<UploadStatus> UploadActivityAsync(StorageFile file, DataFormat dataFormat, ActivityType activityType = ActivityType.Ride) { String format = String.Empty; switch (dataFormat) { case DataFormat.Fit: format = "fit"; break; case DataFormat.FitGZipped: format = "fit.gz"; break; case DataFormat.Gpx: format = "gpx"; break; case DataFormat.GpxGZipped: format = "gpx.gz"; break; case DataFormat.Tcx: format = "tcx"; break; case DataFormat.TcxGZipped: format = "tcx.gz"; break; } HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Add("Authorization", String.Format("Bearer {0}", Authentication.AccessToken)); MultipartFormDataContent content = new MultipartFormDataContent(); byte[] fileBytes = null; using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } var byteArrayContent = new ByteArrayContent(fileBytes); content.Add(byteArrayContent, "file", file.Name); HttpResponseMessage result = await client.PostAsync( String.Format("https://www.strava.com/api/v3/uploads?data_type={0}&activity_type={1}", format, activityType.ToString().ToLower()), content); String json = await result.Content.ReadAsStringAsync(); return Unmarshaller<UploadStatus>.Unmarshal(json); }
public void Show(StorageFile file) { parent = new Popup(); parent.Child = this; parent.IsOpen = true; IRandomAccessStream stream = file.OpenReadAsync().AsTask().Result; Preview.SetSource(stream, file.ContentType); MediaName.Text = file.Name; }
/// <summary> /// 讀取驗證,是否有成功寫入 /// </summary> /// <param name="sb"></param> /// <returns></returns> public async Task ReadText() { _sb.Clear(); using (IRandomAccessStream stream = await sampleFile.OpenReadAsync()) { using (StreamReader rd = new StreamReader(stream.AsStreamForRead(), System.Text.Encoding.UTF8)) { _sb.Append(rd.ReadToEnd()); } } }
public async Task<byte[]> ToArrayAsync(StorageFile storageFile) { var stream = await storageFile.OpenReadAsync(); using (var dataReader = new DataReader(stream)) { var bytes = new byte[stream.Size]; await dataReader.LoadAsync((uint)stream.Size); dataReader.ReadBytes(bytes); return bytes; } }
//public IAsyncOperation<string> CapturePicture() //{ // return getStringHelper().AsAsyncOperation(); //} //private async Task<string> getStringHelper() //{ // var dialog = new CameraCaptureUI(); // var file = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo); // // Do something useful w/ the file // byte[] imageStream = await ToByteArrayAsync(file); // string base64String = Convert.ToBase64String(imageStream); // return base64String; //} private static async Task<byte[]> ToByteArrayAsync(StorageFile file) { using (IRandomAccessStream stream = await file.OpenReadAsync()) { using (DataReader reader = new DataReader(stream.GetInputStreamAt(0))) { await reader.LoadAsync((uint)stream.Size); byte[] Bytes = new byte[stream.Size]; reader.ReadBytes(Bytes); return Bytes; } } }
public static async Task<WriteableBitmap> LoadAsync( this WriteableBitmap writeableBitmap, StorageFile storageFile) { var wb = writeableBitmap; using (var stream = await storageFile.OpenReadAsync()) { await wb.SetSourceAsync(stream); } return wb; }
async void SetSource(StorageFile file) { imageFile = file; var background = (ImageBrush) ImageTile.Background; if(file == null) { background.ImageSource = null; } else { var image = new BitmapImage(); await image.SetSourceAsync(await file.OpenReadAsync()); background.ImageSource = image; } }
public async static Task<byte[]> GetMultiFormPostData(StorageFile file) { var read = await file.OpenReadAsync(); var data = new byte[read.Size]; BinaryReader readerB = new BinaryReader(read.AsStreamForRead()); readerB.Read(data, 0, (int)read.Size); //DataReader reader = new DataReader(read); //await reader.LoadAsync((uint)read.Size); //reader.ReadBytes(data); Dictionary<string, object> param = new Dictionary<string, object>(); param.Add("file", new FileParameter(data, file.Name, "image/jpeg")); return GetMultipartFormData(param, AppSettings.FormDataBoundary); }
/// <summary> /// Get a cropped bitmap from a image file. /// </summary> /// <param name="originalImageFile"> /// The original image file. /// </param> /// <param name="startPoint"> /// The start point of the region to be cropped. /// </param> /// <param name="corpSize"> /// The size of the region to be cropped. /// </param> /// <returns> /// The cropped image. /// </returns> async public static Task<ImageSource> GetCroppedBitmapAsync(StorageFile originalImageFile, Point startPoint, Size corpSize, double scale) { if (double.IsNaN(scale) || double.IsInfinity(scale)) { scale = 1; } // Convert start point and size to integer. uint startPointX = (uint)Math.Floor(startPoint.X * scale); uint startPointY = (uint)Math.Floor(startPoint.Y * scale); uint height = (uint)Math.Floor(corpSize.Height * scale); uint width = (uint)Math.Floor(corpSize.Width * scale); using (IRandomAccessStream stream = await originalImageFile.OpenReadAsync()) { // Create a decoder from the stream. With the decoder, we can get // the properties of the image. BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); // The scaledSize of original image. uint scaledWidth = (uint)Math.Floor(decoder.PixelWidth * scale); uint scaledHeight = (uint)Math.Floor(decoder.PixelHeight * scale); // Refine the start point and the size. if (startPointX + width > scaledWidth) { startPointX = scaledWidth - width; } if (startPointY + height > scaledHeight) { startPointY = scaledHeight - height; } // Get the cropped pixels. byte[] pixels = await GetPixelData(decoder, startPointX, startPointY, width, height, scaledWidth, scaledHeight); // 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)); return cropBmp; } }
private static async Task<byte[]> ReadFile(StorageFile file) { byte[] fileBytes = null; using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } return fileBytes; }
public static async Task<byte[]> ReadFile(StorageFile file) { byte[] fileBytes; using (var stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (var reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } return fileBytes; }
public async static Task<CompoProject> NewFromImage(StorageFile imageFile) { double height; using (var fileStream = await imageFile.OpenReadAsync()) { var decoder = await BitmapDecoder.CreateAsync(fileStream); height = decoder.PixelHeight * DefaultWidth / decoder.PixelWidth; } return new CompoProject( imageFilePath: imageFile.Path, fullHeight: height, fullWidth: DefaultWidth, frames: Gridify(DefaultWidth, height, 2, 2) ); }
private async void ChooseBaseVideo_Click(object sender, RoutedEventArgs e) { var picker = new Windows.Storage.Pickers.FileOpenPicker(); picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.VideosLibrary; picker.FileTypeFilter.Add(".mp4"); baseVideoFile = await picker.PickSingleFileAsync(); if (baseVideoFile == null) { rootPage.NotifyUser("File picking cancelled", NotifyType.ErrorMessage); return; } mediaElement.SetSource(await baseVideoFile.OpenReadAsync(), baseVideoFile.ContentType); chooseOverlayVideo.IsEnabled = true; }
public static async Task<BitmapImage> ResizedImage(StorageFile ImageFile, float ratio) { IRandomAccessStream inputstream = await ImageFile.OpenReadAsync(); BitmapImage sourceImage = new BitmapImage(); sourceImage.SetSource(inputstream); var origHeight = sourceImage.PixelHeight; var origWidth = sourceImage.PixelWidth; var newHeight = (int)(origHeight * ratio); var newWidth = (int)(origWidth * ratio); sourceImage.DecodePixelWidth = newWidth; sourceImage.DecodePixelHeight = newHeight; return sourceImage; }
public static async Task<byte[]> ConvertStorageFileToArrayBytes(StorageFile file) { byte[] fileBytes = null; using (IRandomAccessStreamWithContentType stream = await file.OpenReadAsync()) { fileBytes = new byte[stream.Size]; using (DataReader reader = new DataReader(stream)) { await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(fileBytes); } } // return to azure bytes return fileBytes; }
public static async Task<WriteableBitmap> LoadAsync( this WriteableBitmap writeableBitmap, StorageFile storageFile, uint decodePixelWidth, uint decodePixelHeight) { using (var stream = await storageFile.OpenReadAsync()) { await writeableBitmap.SetSourceAsync( stream, decodePixelWidth, decodePixelHeight); } return writeableBitmap; }
public async static Task<bool> UploadFile(StorageFile file, int corner, bool transparentSignatureBackground) { bool success = false; HttpWebRequest req = CreateWebRequest("/ImageUpload/MobileFileUpload", true); req.AllowReadStreamBuffering = true; try { var randomAccessStream = await file.OpenReadAsync(); var readStream = randomAccessStream.AsStreamForRead(); byte[] fileBytes = new byte[readStream.Length]; await readStream.ReadAsync(fileBytes, 0, fileBytes.Length); StringBuilder serializedBytes = new StringBuilder(); fileBytes.ToList().ForEach(x => serializedBytes.AppendFormat("{0}.", Convert.ToUInt32(x))); string postParameters = String.Format("fileBytes={0}&fileName={1}&radio={2}&transparentBackground={3}", serializedBytes.ToString(), file.Name, corner, transparentSignatureBackground); byte[] postData = Encoding.UTF8.GetBytes(postParameters); var stream = await req.GetRequestStreamAsync(); await stream.WriteAsync(postData, 0, postData.Length); stream.Dispose(); WebResponse result = await req.GetResponseAsync(); if (result.ContentType.Substring(0, 5).Equals("image")) { var responseStream = result.GetResponseStream(); byte[] byteResponse = new byte[responseStream.Length]; await responseStream.ReadAsync(byteResponse, 0, byteResponse.Length); responseStream.Dispose(); if (!Directory.Exists(ApplicationData.Current.LocalFolder.Path + @"\Images")) await ApplicationData.Current.LocalFolder.CreateFolderAsync("Images", CreationCollisionOption.OpenIfExists); StorageFolder imageFolder = await ApplicationData.Current.LocalFolder.GetFolderAsync("Images"); StorageFile markedImageFile = await imageFolder.CreateFileAsync(file.Name, CreationCollisionOption.GenerateUniqueName); File.WriteAllBytes(markedImageFile.Path, byteResponse); success = true; } } catch (Exception E) { Popup errorPopup = new Popup(); } return success; }
private async Task <FaceRectangle> UploadAndDetectFaces(String imageFilePath) { try { Windows.Storage.StorageFolder storageFolder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(imageFilePath)); Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(System.IO.Path.GetFileName(imageFilePath)); var inputStream = await sampleFile.OpenReadAsync(); Stream stream = inputStream.AsStreamForRead(); var faces = await faceServiceClient.DetectAsync(stream); var faceRects = faces.Select(face => face.FaceRectangle); var faceIds = faces.Select(face => face.FaceId).ToArray(); var results = await faceServiceClient.IdentifyAsync(personGroupId, faceIds); for (int j = 0; j < results.Length; j++) { Debug.WriteLine("Result of face: {0}", results[j].FaceId); if (results[j].Candidates.Length == 0) { Debug.WriteLine("No one identified"); } else { var candidateId = results[j].Candidates[0].PersonId; var person = await faceServiceClient.GetPersonAsync(personGroupId, candidateId); Debug.WriteLine("Identified as {0}", person.Name); if (person.Name == "person1") { FaceRectangle rectID; return(rectID = faces[j].FaceRectangle); } } } } catch (Microsoft.ProjectOxford.Face.FaceAPIException exc) { Debug.WriteLine(exc.ErrorCode); } return(null); }
public async Task Load(CanvasDevice device, StorageFile file) { using (var stream = await file.OpenReadAsync()) { SourceBitmap = await CanvasBitmap.LoadAsync(device, stream); } bitmapFormat = sourceBitmap.Format; bitmapData = sourceBitmap.GetPixelBytes(); Size = sourceBitmap.Size.ToVector2(); Edits.Clear(); Edits.Add(new EditGroup(this)); SelectedEffect = null; }
async public static void LoadJson(string name) { Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile sampleFile = await storageFolder.GetFileAsync(name); var randomAccessStream = await sampleFile.OpenReadAsync(); Stream stream = randomAccessStream.AsStreamForRead(); string JsonString = File.ReadAllText(sampleFile.Path); irregularVerbs.WordList = JsonConvert.DeserializeObject <List <IrregularWord> >(JsonString); if (irregularVerbs.WordList == null) { irregularVerbs.WordList = new List <IrregularWord>(); } updateWords(); }
private async void UploadSingleFile(Uri uri, Windows.Storage.StorageFile file) { var httpClientUpload = new HttpClient(); if (file == null) { cts = new CancellationTokenSource(); return; } Stream stream = new MemoryStream(); using (IRandomAccessStream fileStream = await file.OpenAsync(FileAccessMode.Read)) { fileStream.AsStream().CopyTo(stream); } try { IProgress <HttpProgress> progress = new Progress <HttpProgress>(UploadProgressHandler); HttpStreamContent streamContent = new HttpStreamContent(await file.OpenReadAsync()); streamContent.Headers.ContentDisposition = new HttpContentDispositionHeaderValue("attachment") { Name = "\"" + file.Name + "\"", FileName = "\"" + file.Name + "\"", }; HttpMultipartFormDataContent form = new HttpMultipartFormDataContent { { streamContent, "file", file.Name } }; HttpResponseMessage responseUpload = await httpClientUpload.PostAsync(uri, form).AsTask(cts.Token, progress); } catch (TaskCanceledException) { return; } catch (Exception ex) { return; } }
private async void btnTakeImage_OnClick(object sender, RoutedEventArgs e) { CameraCaptureUI cameraCaptureUi = new CameraCaptureUI(); cameraCaptureUi.PhotoSettings.AllowCropping = false; cameraCaptureUi.PhotoSettings.MaxResolution = CameraCaptureUIMaxPhotoResolution.MediumXga; _storageFile = await cameraCaptureUi.CaptureFileAsync(CameraCaptureUIMode.Photo); if (_storageFile != null) { BitmapImage bitmapImage = new BitmapImage(); bitmapImage.SetSource(await _storageFile.OpenReadAsync()); CurrentImage.Source = bitmapImage; } }
private async void OnCaptureVideoButtonClick(object sender, RoutedEventArgs e) { if (!_capturingVideo) { CaptureVideoButton.Content = "Stop"; _capturingVideo = true; _videoFile = await TestedControl.StartVideoCaptureAsync(ApplicationData.Current.TemporaryFolder); CapturedVideoElement.Visibility = Visibility.Visible; PhotoImage.Visibility = Visibility.Collapsed; IRandomAccessStreamWithContentType stream; try { stream = await TryCatchRetry.RunWithDelayAsync<Exception, IRandomAccessStreamWithContentType>( _videoFile.OpenReadAsync(), TimeSpan.FromSeconds(0.5), 10); } catch (Exception ex) { #pragma warning disable 4014 // Seems like a bug with WinRT not closing the file sometimes that it writes the video to. new MessageDialog(ex.Message, "Error").ShowAsync(); #pragma warning restore 4014 return; } if (this.CapturedVideoElement == null) { return; } this.CapturedVideoElement.SetSource(stream, _videoFile.ContentType); } else { CaptureVideoButton.Content = "Record"; _capturingVideo = false; await TestedControl.StopCapture(); } }
async Task<string> ReadTextAsync(StorageFile file) { #if NETFX_CORE var text = await FileIO.ReadTextAsync(file); #else var text = default(string); using (var stream = await file.OpenReadAsync()) { var size = stream.Size; using (var inputStream = stream.GetInputStreamAt(0)) { var dataReader = new DataReader(inputStream); uint numBytesLoaded = await dataReader.LoadAsync((uint)size); text = dataReader.ReadString(numBytesLoaded); } } #endif return text; }
/// <summary> /// Gets the music info from the supplied filename and subfolder name. /// The main folder is defaulted to the User's Music Library as a /// Known folder /// </summary> /// <param name="musicFile">The instance of the music file to be read.</param> /// <returns>An instance of the music file, includeing Tag information</returns> public static async Task<TagLib.File> GetMusicFileInfoAsync(StorageFile musicFile) { MusicFileInfo musicFileInformation = new MusicFileInfo(); // Use Taglib Sharp to get the tag information. // 1. Create a file abstraction to avoid using banned libraries // http://stackoverflow.com/questions/13381494/c-sharp-windows-store-app-granting-capabilities-to-used-dll-s // Explanation is as follows // You can use TagLibSharp to load tags by creating a StreamFileAbstraction and passing that to File.Create. // This won't use any banned APIs. // // The StreamFileAbstraction class is defined below. // I claim no credit for this, just that it works nicely. The resource is disposed of // as the class inherits the Taglib.file.IFileAbstraction class. IRandomAccessStreamWithContentType f = await musicFile.OpenReadAsync(); TagLib.File taglibMusicFile = TagLib.File.Create(new StreamFileAbstraction(musicFile.Name, f.AsStream())); return taglibMusicFile; }
public async void printValues() { Paragraph deskQuoteObjects = new Paragraph(); Run deskQuoteObjectRun = new Run(); Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile file = await storageFolder.GetFileAsync("quotes.json"); using (var inputStream = await file.OpenReadAsync()) using (var classicStream = inputStream.AsStreamForRead()) using (var streamReader = new StreamReader(classicStream)) { while (streamReader.Peek() >= 0) { string json = streamReader.ReadLine(); DeskQuote printQuote = JsonConvert.DeserializeObject <DeskQuote>(json); deskQuoteObjectRun.Text += "Date: \t" + printQuote.date + "\n First Name: \t" + printQuote.FirstName + "\n Last Name: \t" + printQuote.LastName + "\n Desk Specs:" + "\n Width: \t\t" + System.Convert.ToString(printQuote.newDesk1.width) + "\n Depth: \t\t" + System.Convert.ToString(printQuote.newDesk1.depth) + "\n Drawers: \t" + System.Convert.ToString(printQuote.newDesk1.drawerCount) + "\n Material: \t\t" + System.Convert.ToString(printQuote.newDesk1.surface) + "\n Shipping: \t" + System.Convert.ToString(printQuote.ShippingDays) + " Day" + "\n Total Cost: \t" + "$" + System.Convert.ToString(printQuote.DeskCost + printQuote.ShippingCost) + "\n" + "==============================" + "\n"; } deskQuoteObjects.Inlines.Add(deskQuoteObjectRun); ViewAQuotes.Blocks.Add(deskQuoteObjects); } }
private async void ReadBook_Click(object sender, RoutedEventArgs e) { //open file picker var picker = new Windows.Storage.Pickers.FileOpenPicker(); //show icons as thumbnails picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.Thumbnail; //open on desktop if not opened before picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Desktop; //only need txt or epub files picker.FileTypeFilter.Add(".txt"); Windows.Storage.StorageFile file = await picker.PickSingleFileAsync(); if (file != null) { IRandomAccessStream sr = await file.OpenReadAsync(); byte[] result; using (Stream stream = await file.OpenStreamForReadAsync()) { using (var memoryStream = new MemoryStream()) { stream.CopyTo(memoryStream); result = memoryStream.ToArray(); } } var folder = ApplicationData.Current.LocalFolder; StorageFolder subFolder; try { subFolder = await folder.GetFolderAsync("books"); } catch (FileNotFoundException) { subFolder = await folder.CreateFolderAsync("books"); } /*await subFolder.DeleteAsync(); * await folder.CreateFolderAsync("books"); * var k = await folder.GetFoldersAsync(); * foreach(StorageFolder sf in k) * { * await sf.DeleteAsync(); * }*/ if (!await isFilePresent(file.Name, subFolder)) { file = await subFolder.CreateFileAsync(file.Name); await FileIO.WriteBytesAsync(file, result); String str = await new TxtParser().readFile(file); Book b = new Book(str); String read = ""; int counter = 0; var fileFolder = await folder.CreateFolderAsync(file.DisplayName); MessageDialog dialog = new MessageDialog("Synthesizing speech, this can take a few minutes, we'll let you know when we're done" + " Please don't close the app"); await dialog.ShowAsync(); while ((read = b.popSegment()) != null) { await new Speaker().StoreText(read, file.DisplayName, counter.ToString(), fileFolder); counter++; } updateBookPhrases(); dialog = new MessageDialog("File Synthesized, thank you for waiting"); await dialog.ShowAsync(); //update bindings books.AddBook(file.Name); this.DataContextChanged += (s, DataContextChangedEventArgs) => this.Bindings.Update(); } else { MessageDialog dialog = new MessageDialog("Book with that name already in library"); await dialog.ShowAsync(); } } }