public async Task CaptureToFile() { //<SnippetCaptureToFile> var myPictures = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures); StorageFile file = await myPictures.SaveFolder.CreateFileAsync("photo.jpg", CreationCollisionOption.GenerateUniqueName); using (var captureStream = new InMemoryRandomAccessStream()) { await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(captureStream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(fileStream, decoder); var properties = new BitmapPropertySet { { "System.Photo.Orientation", new BitmapTypedValue(PhotoOrientation.Normal, PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); } } //</SnippetCaptureToFile> }
/// <summary> /// Captures a photo. Photo data is stored to ImageStream, and /// application is navigated to the preview page after capturing. /// </summary> private async Task Capture() { bool goToPreview = false; if (!_capturing) { CapturePreview.Source = null; Progress.IsActive = true; _capturing = true; _dataContext.ResetStreams(); IRandomAccessStream stream = _dataContext.FullResolutionStream.AsRandomAccessStream(); await _photoCaptureManager.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); await _photoCaptureManager.StopPreviewAsync(); await AppUtils.ScaleImageStreamAsync( _dataContext.FullResolutionStream, _dataContext.FullResolution, _dataContext.PreviewResolutionStream, _dataContext.PreviewResolution); _capturing = false; goToPreview = true; } if (goToPreview) { _dataContext.WasCaptured = true; Frame.Navigate(typeof(PreviewPage)); } }
private async Task <Result> GetCameraImage(CancellationToken cancelToken) { if (cancelToken.IsCancellationRequested) { throw new OperationCanceledException(cancelToken); } imageStream = new InMemoryRandomAccessStream(); await capture.CapturePhotoToStreamAsync(encodingProps, imageStream); await imageStream.FlushAsync(); var decoder = await BitmapDecoder.CreateAsync(imageStream); byte[] pixels = (await decoder.GetPixelDataAsync(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, new BitmapTransform(), ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage)).DetachPixelData(); const BitmapFormat format = BitmapFormat.RGB32; imageStream.Dispose(); var result = await Task.Run( () => barcodeReader.Decode(pixels, (int)decoder.PixelWidth, (int)decoder.PixelHeight, format), cancelToken); return(result); }
public async Task CapturePhoto() { try { if ((App.Current as App).IsProcessingPicture) { return; } (App.Current as App).IsProcessingPicture = true; using (var randomAccessStream = new InMemoryRandomAccessStream()) { await mediaCapture.CapturePhotoToStreamAsync(Windows.Media.MediaProperties.ImageEncodingProperties.CreateJpeg(), randomAccessStream); randomAccessStream.Seek(0); var outStream = new InMemoryRandomAccessStream(); var task = new Task(() => { this.EncodedPhoto(randomAccessStream, outStream); }); task.Start(); Frame.Navigate(typeof(PictureEdit), outStream); }; } catch (Exception ex) { Debug.WriteLine(ex.Message); } }
public async Task <byte[]> CapturePhotoWithOrientationAsync() { var captureStream = new InMemoryRandomAccessStream(); var outputStream = new InMemoryRandomAccessStream(); try { await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); } catch (Exception ex) { _loggingService.Warning("Exception when taking a photo: {Ex}", ex); await _dialogService.ShowAsync("Could not take a photo. Please try again."); return(new byte[0]); } var decoder = await BitmapDecoder.CreateAsync(captureStream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(outputStream, decoder); var cameraOrientation = _cameraRotationHelper.GetCameraCaptureOrientation(); var simplePhotoOrientation = _cameraRotationHelper.MirrorOrientation(cameraOrientation); var photoOrientation = _cameraRotationHelper.ConvertSimpleOrientationToPhotoOrientation(simplePhotoOrientation); var properties = new BitmapPropertySet { { "System.Photo.Orientation", new BitmapTypedValue(photoOrientation, PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); var rawBytes = await _bitmapConverter.GetBytesFromStream(outputStream); return(rawBytes); }
/// <summary> /// Takes a photo to a StorageFile and adds rotation metadata to it /// </summary> /// <returns></returns> private async Task TakeNormalPhotoAsync() { var stream = new InMemoryRandomAccessStream(); try { Debug.WriteLine("Taking photo..."); // Generate a filename based on the current time var fileName = String.Format("SimplePhoto_{0}.jpg", DateTime.Now.ToString("HHmmss")); // Get the orientation of the camera at the time of capture var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation()); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); Debug.WriteLine("Photo taken!"); await ReencodeAndSavePhotoAsync(stream, fileName, photoOrientation); } catch (Exception ex) { // File I/O errors are reported as exceptions Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString()); } }
/// <summary> /// Основная функция, срабатывающая по таймеру /// Распознаёт эмоции /// </summary> async void GetEmotions(object sender, object e) { if (!IsFacePresent) { return; } dt.Stop(); var ms = new MemoryStream(); try { // Запоминаем фотографию в поток в памяти await MC.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), ms.AsRandomAccessStream()); } catch { dt.Start(); return; } ms.Position = 0L; var Emo = await Oxford.RecognizeAsync(ms); // ^^^ основной вызов распознавателя эмоций if (Emo != null && Emo.Length > 0) // если обнаружено одно и более лицо { var Face = Emo[0]; // берем первое (нулевое) лицо // Face.Scores - запись с различными эмоциями (Fear,Surprise,...) Info.Text = ((int)(100 * Face.Scores.Happiness)).ToString(); } dt.Start(); // перезапускаем таймер }
async private void AppBarButton_Click(object sender, RoutedEventArgs e) { try { var vm = this.DataContext as CameraCapturePageViewModel; var imageEncodingProps = ImageEncodingProperties.CreatePng(); using (var stream = new InMemoryRandomAccessStream()) { await _mediaCapture.CapturePhotoToStreamAsync(imageEncodingProps, stream); _bytes = new byte[stream.Size]; var buffer = await stream.ReadAsync(_bytes.AsBuffer(), (uint)stream.Size, InputStreamOptions.None); _bytes = buffer.ToArray(0, (int)stream.Size); if (vm.ImageSource == null) { vm.ImageSource = new BitmapImage(); } stream.Seek(0); await vm.ImageSource.SetSourceAsync(stream); Retake.Visibility = Windows.UI.Xaml.Visibility.Visible; Take.Visibility = Windows.UI.Xaml.Visibility.Collapsed; await _mediaCapture.StopPreviewAsync(); } } catch (Exception) { throw; } }
public async Task TakePhotoAsync(Action <SoftwareBitmapSource> callback) { //kada uslika postaviti svoj stream Slika = new InMemoryRandomAccessStream(); try { //konvertovati uslikano u Software bitmap da se moze prikazati u image kontroli await MediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateBmp(), Slika); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(Slika); SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(); SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied); SlikaBitmap = new SoftwareBitmapSource(); await SlikaBitmap.SetBitmapAsync(softwareBitmapBGR8); callback(SlikaBitmap); } catch (Exception ex) { Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString()); } }
private async void button_Click(object sender, RoutedEventArgs e) { button.IsEnabled = false; button2.IsEnabled = false; PB.Visibility = Visibility.Visible; using (var captureStream = new InMemoryRandomAccessStream()) { await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); using (var s = captureStream.AsStream()) { //await _mediaCapture.CapturePhotoToStorageFileAsync(ImageEncodingProperties.CreatePng(), file); var credentials = new StorageCredentials("vrdreamer", "lTD5XmjEhvfUsC/vVTLsl01+8pJOlMdF/ri7W1cNOydXwSdb8KQpDbiveVciOqdIbuDu6gJW8g44YtVjuBzFkQ=="); var client = new CloudBlobClient(new Uri("https://vrdreamer.blob.core.windows.net/"), credentials); var container = client.GetContainerReference("datasetimages"); var blockBlob = container.GetBlockBlobReference(Guid.NewGuid().ToString() + ".jpeg"); s.Position = 0; await blockBlob.UploadFromStreamAsync(s); ////await blockBlob.UploadFromFileAsync(captureStream); blobUrl = blockBlob.StorageUri.PrimaryUri.ToString(); var add = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.116 Safari/537.36"; var httpRequestMessage = new Windows.Web.Http.HttpRequestMessage(Windows.Web.Http.HttpMethod.Get, new Uri("http://www.google.com/searchbyimage?site=search&sa=X&image_url=" + blockBlob.StorageUri.PrimaryUri.ToString())); httpRequestMessage.Headers.Add("User-Agent", add); //items2 = await Table2.ToCollectionAsync(); web.NavigateWithHttpRequestMessage(httpRequestMessage); web.DOMContentLoaded += Web_DOMContentLoaded; } } }
public async Task<string> TakePhoto() { if (_capturing) { return null; } _capturing = true; using (var stream = new InMemoryRandomAccessStream()) { await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); var photoOrientation = _displayInformation.ToSimpleOrientation(_deviceOrientation, _mirroringPreview).ToPhotoOrientation(); if (_mirroringPreview) { photoOrientation = PhotoOrientation.FlipHorizontal; } var photo = await ReencodeAndSavePhotoAsync(stream, photoOrientation); PhotoTaken?.Invoke(this, new CameraControlEventArgs(photo)); _capturing = false; return photo; } }
public async Task <Stream> GetCurrentFrameAsync() { if (CurrentState != ScenarioState.Streaming) { return(null); } // If a lock is being held it means we're still waiting for processing work on the previous frame to complete. // In this situation, don't wait on the semaphore but exit immediately. if (!frameProcessingSemaphore.Wait(0)) { return(null); } try { var stream = new InMemoryRandomAccessStream(); await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); stream.Seek(0); return(stream.AsStreamForRead()); } catch { } finally { frameProcessingSemaphore.Release(); } return(null); }
private async void ImageUpload(string deviceId) { try { using (Windows.Storage.Streams.InMemoryRandomAccessStream captureStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); await captureStream.FlushAsync(); captureStream.Seek(0); // Drops file onto device file system for debugging only #if DEBUG IStorageFile photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync("Timelapse.jpg", CreationCollisionOption.ReplaceExisting); ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg(); await mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile); #endif LoggingService.Log("ImageUploadService Upload starting"); ImageUploadService.Upload(deviceId, captureStream); LoggingService.Log("ImageUploadService Upload done"); } } catch (Exception ex) { LoggingService.Error($"Image capture or upload failed ", ex); } }
/// <summary> /// Takes a photo to a StorageFile and adds rotation metadata to it /// </summary> /// <returns></returns> private async Task TakeNormalPhotoAsync() { var stream = new InMemoryRandomAccessStream(); try { Debug.WriteLine("Taking photo..."); // Read the current orientation of the camera and the capture time var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation()); var fileName = String.Format("SimplePhoto_{0}.jpg", DateTime.Now.ToString("HHmmss")); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); var file = await _captureFolder.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName); Debug.WriteLine("Photo taken! Saving to " + file.Path); await ReencodeAndSavePhotoAsync(stream, file, photoOrientation); } catch (Exception ex) { // File I/O errors are reported as exceptions Debug.WriteLine("Exception when taking a photo: " + ex.ToString()); } }
public MainPage() { this.InitializeComponent(); InitAsync(); Timer.Interval = TimeSpan.FromSeconds(3); Timer.Tick += async(sender, o) => { if (!(MediaCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview) is VideoEncodingProperties properties)) { return; } //Jpeg形式でガメラの最大解像度で取得する。 var property = ImageEncodingProperties.CreateJpeg(); property.Width = properties.Width; property.Height = properties.Height; using (var randomStream = new InMemoryRandomAccessStream()) { await MediaCapture.CapturePhotoToStreamAsync(property, randomStream); randomStream.Seek(0); var peoplePhotoUrl = await UploadToBlob(randomStream); this.FaceResultText.Text = GetCongestionText((await PredictionWithCustomVisionService(peoplePhotoUrl))); //var detectedFaces = await DetectFaceAsync(randomStream); //this.FaceResultText.Text = $"{detectedFaces.Count} 個。{GetCongestionText(detectedFaces.Count)}"; } }; }
private async void CounterCallback(object sender, object e) { counter--; Counter.Text = counter.ToString(); if (counter == 0) { dt.Stop(); if (DFace == null) { return; } var ms = new MemoryStream(); await MC.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), ms.AsRandomAccessStream()); Point p; Size sz; ExpandFaceRect1(DFace.FaceBox, out p, out sz); var cb = await CropBitmap.GetCroppedBitmapAsync(ms.AsRandomAccessStream(), p, sz, 1); Faces.Add(cb); var res = await CallCognitiveFunction(ms); ResultImage.Source = new BitmapImage(new Uri(res)); await WriteableBitmapToStorageFile(cb); Counter.Visibility = Visibility.Collapsed; } }
private void CaptureCameraSnapshot() { var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { animCameraTimer.Stop(); animCameraTimer.Begin(); }); if (_mediaCapture.CameraStreamState != Windows.Media.Devices.CameraStreamState.Streaming) { return; } IRandomAccessStream stream = new InMemoryRandomAccessStream(); try { IAsyncAction action = _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); action.Completed = (result, status) => { if (status == AsyncStatus.Completed) { OnCapturePhotoCompleted(stream, result, status); } }; } catch (Exception) { if (stream != null) { stream.Dispose(); stream = null; } } }
private async void Button_Tapped(object sender, TappedRoutedEventArgs e) { StorageFolder picturesLibrary = KnownFolders.PicturesLibrary; StorageFolder savedPicturesFolder = await picturesLibrary.CreateFolderAsync("PhotoApp Pictures", CreationCollisionOption.OpenIfExists); StorageFile file = await savedPicturesFolder.CreateFileAsync("photo.jpg", CreationCollisionOption.GenerateUniqueName); using (var captureStream = new InMemoryRandomAccessStream()) { await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(captureStream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(fileStream, decoder); var properties = new BitmapPropertySet { { "System.Photo.Orientation", new BitmapTypedValue(PhotoOrientation.Normal, PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); } } }
/// <summary> /// Takes a photo to a StorageFile and adds rotation metadata to it /// </summary> /// <returns></returns> private async Task TakePhotoAsync() { var stream = new InMemoryRandomAccessStream(); Debug.WriteLine("Taking photo..."); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); try { var file = await _captureFolder.CreateFileAsync("SimplePhoto.jpg", CreationCollisionOption.ReplaceExisting); Debug.WriteLine("Photo taken! Saving to " + file.Path); var photoOrientation = CameraRotationHelper.ConvertSimpleOrientationToPhotoOrientation(_rotationHelper.GetCameraCaptureOrientation()); await ReencodeAndSavePhotoAsync(stream, file, photoOrientation); Debug.WriteLine("Photo saved!"); } catch (Exception ex) { // File I/O errors are reported as exceptions Debug.WriteLine("Exception when taking a photo: " + ex.ToString()); } }
private async void Button_Click(object sender, RoutedEventArgs e) { var myPictures = await StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures); var file = await myPictures.SaveFolder.CreateFileAsync("xaml-islands.jpg", CreationCollisionOption.GenerateUniqueName); using (var captureStream = new InMemoryRandomAccessStream()) { await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(captureStream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(fileStream, decoder); var properties = new BitmapPropertySet { { "System.Photo.Orientation", new BitmapTypedValue(PhotoOrientation.Normal, PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); imgCollection.Add(file.Path); } } }
async void OnCameraPreviewTapped(object sender, TappedRoutedEventArgs e) { var stream = new InMemoryRandomAccessStream(); if (isPreviewing) { await mediaCapture.StopPreviewAsync(); await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); // transforma em bytes var reader = new DataReader(stream.GetInputStreamAt(0)); var bytes = new byte[stream.Size]; await reader.LoadAsync((uint)stream.Size); reader.ReadBytes(bytes); Xamarin.Forms.DependencyService.Get <ICameraOption>().ImagemCapturada(bytes); isPreviewing = false; } else { await mediaCapture.StartPreviewAsync(); isPreviewing = true; } }
public async Task TakePhotoAsync() { var stream = new InMemoryRandomAccessStream(); imeSlike = "Slika" + redniBroj.ToString() + ".jpg"; redniBroj++; Debug.WriteLine("Taking photo..."); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); //var ovajfolder = Windows.Storage.ApplicationData.Current.LocalFolder; //_captureFolder = await ovajfolder.GetFolderAsync("Slike"); //_captureFolder = ovajfolder; var picturesLibrary = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures); // Fall back to the local app storage if the Pictures Library is not available _captureFolder = picturesLibrary.SaveFolder ?? ApplicationData.Current.LocalFolder; //_captureFolder = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("Slike\\"); try { var file = await _captureFolder.CreateFileAsync(imeSlike, CreationCollisionOption.GenerateUniqueName); Debug.WriteLine("Photo taken! Saving to " + file.Path); mjesto = file.Path; await ReencodeAndSavePhotoAsync(stream, file, PhotoOrientation.Normal); Debug.WriteLine("Photo saved!"); } catch (Exception ex) { // File I/O errors are reported as exceptions Debug.WriteLine("Exception when taking a photo: " + ex.ToString()); } }
/// <summary> /// Detect face by using local function. /// </summary> private async Task <InMemoryRandomAccessStream> DetectFaceAsync() { var imgFormat = ImageEncodingProperties.CreateJpeg(); while (true) { try { var stream = new InMemoryRandomAccessStream(); await mediaCapture.CapturePhotoToStreamAsync(imgFormat, stream); var image = await ImageConverter.ConvertToSoftwareBitmapAsync(stream); detectedFaces = await faceDetector.DetectFacesAsync(image); if (detectedFaces.Count == 0) { continue; } else if (detectedFaces.Count != 1) { Message = "too many faces!"; } else { return(stream); } } catch (Exception ex) { } } }
private async Task<ImageAnalyzer> CapturePhotoAsync() { try { var stream = new MemoryStream(); await captureManager.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream.AsRandomAccessStream()); stream.Position = 0; ImageAnalyzer imageWithFace = new ImageAnalyzer(stream.ToArray()); imageWithFace.ShowDialogOnFaceApiErrors = this.ShowDialogOnApiErrors; imageWithFace.FilterOutSmallFaces = this.FilterOutSmallFaces; imageWithFace.UpdateDecodedImageSize(this.CameraResolutionHeight, this.CameraResolutionWidth); return imageWithFace; } catch (Exception ex) { if (this.ShowDialogOnApiErrors) { await Util.GenericApiCallExceptionHandler(ex, "Error capturing photo."); } } return null; }
/// <summary> /// Takes a photo to a StorageFile and adds rotation metadata to it /// </summary> /// <returns></returns> private async Task TakePhotoAsync() { // While taking a photo, keep the video button enabled only if the camera supports simultaneosly taking pictures and recording video VideoButton.IsEnabled = _mediaCapture.MediaCaptureSettings.ConcurrentRecordAndPhotoSupported; // Make the button invisible if it's disabled, so it's obvious it cannot be interacted with VideoButton.Opacity = VideoButton.IsEnabled ? 1 : 0; var stream = new InMemoryRandomAccessStream(); try { Debug.WriteLine("Taking photo..."); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); Debug.WriteLine("Photo taken!"); var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation()); await ReencodeAndSavePhotoAsync(stream, photoOrientation); } catch (Exception ex) { Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString()); } // Done taking a photo, so re-enable the button VideoButton.IsEnabled = true; VideoButton.Opacity = 1; }
public static async void CaptureOnePhoto(int type, Action <IRandomAccessStream> overAction) { var captureTime = DateTime.Now; if (type == 0) { using (IRandomAccessStream s = new InMemoryRandomAccessStream()) { await MainCamera.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), s); overAction(s); } } else if (type == 1) { if (LowLag == null) { return; } var photoData = await LowLag.CaptureAsync(); using (var stream = photoData.Frame.CloneStream()) { overAction(stream); } } }
/// <summary> /// Takes a photo to a StorageFile and adds rotation metadata to it /// </summary> /// <returns></returns> private async Task TakePhotoAsync() { // While taking a photo, keep the video button enabled only if the camera supports simultaneously taking pictures and recording video VideoButton.IsEnabled = _mediaCapture.MediaCaptureSettings.ConcurrentRecordAndPhotoSupported; // Make the button invisible if it's disabled, so it's obvious it cannot be interacted with VideoButton.Opacity = VideoButton.IsEnabled ? 1 : 0; var stream = new InMemoryRandomAccessStream(); Debug.WriteLine("Taking photo..."); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); try { var file = await _captureFolder.CreateFileAsync("SimplePhoto.jpg", CreationCollisionOption.GenerateUniqueName); Debug.WriteLine("Photo taken! Saving to " + file.Path); var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation()); await ReencodeAndSavePhotoAsync(stream, file, photoOrientation); Debug.WriteLine("Photo saved!"); } catch (Exception ex) { // File I/O errors are reported as exceptions Debug.WriteLine("Exception when taking a photo: " + ex.ToString()); } // Done taking a photo, so re-enable the button VideoButton.IsEnabled = true; VideoButton.Opacity = 1; }
/// <summary> /// Основная функция, срабатывающая по таймеру /// Распознаёт эмоции /// </summary> async void GetEmotions(object sender, object e) { if (!IsFacePresent) { return; } dt.Stop(); var ms = new MemoryStream(); try { // Запоминаем фотографию в поток в памяти await MC.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), ms.AsRandomAccessStream()); } catch { dt.Start(); return; } ms.Position = 0L; var Emo = await Oxford.RecognizeAsync(ms); // ^^^ основной вызов распознавателя эмоций if (Emo != null && Emo.Length > 0) // если обнаружено одно и более лицо { var Face = Emo[0]; // берем первое (нулевое) лицо // Face.Scores - запись с различными эмоциями (Fear,Surprise,...) // Сериализуем в JSON var s = JsonConvert.SerializeObject(Face.Scores); // TODO: Здесь мы можем делать что хотим с сериализованной строкой // Например, печатать: System.Diagnostics.Debug.WriteLine(s); } dt.Start(); // перезапускаем таймер }
/// <summary> /// Central button clicked to take a picture /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void Button_Click(object sender, RoutedEventArgs e) { await StopCapture(); var myPictures = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Pictures); StorageFile file = await myPictures.SaveFolder.CreateFileAsync( Path.Combine(Protocol.NewFaceFolder, UserManager.Instance.CurrentProfile.Name + ".jpg"), CreationCollisionOption.ReplaceExisting); using (var captureStream = new InMemoryRandomAccessStream()) { await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); using (var fileStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { var decoder = await BitmapDecoder.CreateAsync(captureStream); var encoder = await BitmapEncoder.CreateForTranscodingAsync(fileStream, decoder); var properties = new BitmapPropertySet { { "System.Photo.Orientation", new BitmapTypedValue(PhotoOrientation.Normal, PropertyType.UInt16) } }; await encoder.BitmapProperties.SetPropertiesAsync(properties); await encoder.FlushAsync(); } } PhotoRegistred(); }
/// <summary> /// Takes a photo to a StorageFile and adds rotation metadata to it /// </summary> /// <returns></returns> private async Task TakePhotoAsync() { var stream = new InMemoryRandomAccessStream(); try { Debug.WriteLine("Taking photo..."); await _mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), stream); Debug.WriteLine("Photo taken!"); var photoOrientation = ConvertOrientationToPhotoOrientation(GetCameraOrientation()); var file = await ReencodeAndSavePhotoAsync(stream, photoOrientation); Emotion[] emotions = await GetEmotionsAsync(file); await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => HighlightDetectedFacesWithEmotions(emotions)); Debug.WriteLine($"{emotions}"); //await ReencodeAndSavePhotoAsync(stream, photoOrientation); } catch (Exception ex) { // File I/O errors are reported as exceptions Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString()); } }