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); } }
private async Task<byte[]> ImageToBytes(IRandomAccessStream sourceStream) { byte[] imageArray; BitmapDecoder decoder = await BitmapDecoder.CreateAsync(sourceStream); var transform = new BitmapTransform { ScaledWidth = decoder.PixelWidth, ScaledHeight = decoder.PixelHeight }; PixelDataProvider pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); using (var destinationStream = new InMemoryRandomAccessStream()) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, decoder.PixelWidth, decoder.PixelHeight, 96, 96, pixelData.DetachPixelData()); await encoder.FlushAsync(); BitmapDecoder outputDecoder = await BitmapDecoder.CreateAsync(destinationStream); await destinationStream.FlushAsync(); imageArray = (await outputDecoder.GetPixelDataAsync()).DetachPixelData(); } return imageArray; }
public static async Task<InMemoryRandomAccessStream> ConvertToInMemoryStream(byte[] arr) { var randomAccessStream = new InMemoryRandomAccessStream(); await randomAccessStream.WriteAsync(arr.AsBuffer()); randomAccessStream.Seek(0); await randomAccessStream.FlushAsync(); // TODO: don't sure it's needed return randomAccessStream; }
public void SetSource(byte[] bytes) { var ms = new InMemoryRandomAccessStream(); ms.WriteAsync(bytes.AsBuffer()); ms.FlushAsync().AsTask().Wait(); ms.Seek(0); bitmap = new BitmapImage(); bitmap.SetSource(ms); }
public async Task SaveBitmapAsync(string albumFolder, uint size, string songPath) { var songFile = await StorageFile.GetFileFromPathAsync(songPath); using (var thumbnail = await songFile.GetThumbnailAsync(ThumbnailMode.MusicView, size) ?? await songFile.GetThumbnailAsync(ThumbnailMode.VideosView, size)) { if (thumbnail == null) return; var reader = new DataReader(thumbnail); var fileLength = (uint)thumbnail.Size; await reader.LoadAsync(fileLength); var buffer = reader.ReadBuffer(fileLength); var memStream = new InMemoryRandomAccessStream(); await memStream.WriteAsync(buffer); await memStream.FlushAsync(); memStream.Seek(0); await ApplicationData.Current.LocalFolder.CreateFolderAsync(AlbumArtFolderName(albumFolder), CreationCollisionOption.OpenIfExists); var albumArtFileName = AlbumArtFileName(albumFolder, size); var outputFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(albumArtFileName, CreationCollisionOption.ReplaceExisting); // http://social.msdn.microsoft.com/Forums/windowsapps/en-US/1dda3a15-d299-40e0-b668-ec690a683f6e/how-to-resize-an-image-as-storagefile?forum=winappswithcsharp var decoder = await BitmapDecoder.CreateAsync(memStream); var transform = new BitmapTransform { ScaledHeight = size, ScaledWidth = size }; var pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.RespectExifOrientation, ColorManagementMode.DoNotColorManage); using (var destinationStream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, destinationStream); encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied, size, size, 96, 96, pixelData.DetachPixelData()); await encoder.FlushAsync(); } } }
private async void DownloadAndScale(string outfileName, string downloadUriString) { Uri downLoadingUri = new Uri(downloadUriString); var client = new HttpClient(); using (var response = await client.GetAsync(downLoadingUri)) { var buffer = await response.Content.ReadAsBufferAsync(); var memoryStream = new InMemoryRandomAccessStream(); await memoryStream.WriteAsync(buffer); await memoryStream.FlushAsync(); var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryStream); var pixelProvider = await decoder.GetPixelDataAsync(); var localFolder = Windows.Storage.KnownFolders.PicturesLibrary; var scaledFile = await localFolder.CreateFileAsync(outfileName, CreationCollisionOption.GenerateUniqueName); using (var scaledFileStream = await scaledFile.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) { var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync( BitmapEncoder.JpegEncoderId, scaledFileStream); var pixels = pixelProvider.DetachPixelData(); encoder.SetPixelData( decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, decoder.PixelWidth, decoder.PixelHeight, decoder.DpiX, decoder.DpiY, pixels ); await encoder.FlushAsync(); } } }
/// <summary> /// Perform image capture from mediaCapture object /// </summary> /// <param name="cancelToken"> /// The cancel Token. /// </param> /// <returns> /// Decoded barcode string. /// </returns> 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; }
private async Task<bool> LoadImageFromHttpResponse(HttpResponseMessage response, Tile tile, BitmapSource image, string cacheKey) { using (var stream = new InMemoryRandomAccessStream()) { using (var content = response.Content) { await content.WriteToStreamAsync(stream); } await stream.FlushAsync(); stream.Seek(0); var loaded = await LoadImageFromStream(tile, image, stream); if (loaded && cacheKey != null) { var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); stream.Seek(0); await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); var maxAge = DefaultCacheExpiration; if (response.Headers.CacheControl.MaxAge.HasValue && response.Headers.CacheControl.MaxAge.Value < maxAge) { maxAge = response.Headers.CacheControl.MaxAge.Value; } await Cache.SetAsync(cacheKey, buffer, DateTime.UtcNow.Add(maxAge)); } return loaded; } }
private async void AnalyzeButton_Click(object sender, RoutedEventArgs e) { if (processingImage) { // Ignore button presses while processing the image return; } if (inCaptureState) { processingImage = true; inCaptureState = false; // Make the 'Processing...' label visible canvasControl.Visibility = Visibility.Visible; AnalyzeButton.Content = "..."; canvasControl.Invalidate(); var originalPhoto = new InMemoryRandomAccessStream(); var reencodedPhoto = new InMemoryRandomAccessStream(); await mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), originalPhoto); await originalPhoto.FlushAsync(); originalPhoto.Seek(0); captureElement.Visibility = Visibility.Collapsed; // Store the captured photo as a Win2D type for later use photoCanvasBitmap = await CanvasBitmap.LoadAsync(canvasControl, originalPhoto); // Send the photo to Project Oxford to detect the faces lastCapturedFaces = await faceServiceClient.DetectAsync(originalPhoto.AsStreamForRead(), true, true, true, false); // Force the canvasControl to be redrawn now that the photo is available canvasControl.Invalidate(); processingImage = false; AnalyzeButton.Content = "Restart"; } else { canvasControl.Visibility = Visibility.Collapsed; captureElement.Visibility = Visibility.Visible; AnalyzeButton.Content = "Capture Photo"; photoCanvasBitmap = null; canvasControl.Invalidate(); inCaptureState = true; } }
public async Task<IRandomAccessStream> DownloadPDFAsync(LibrelioUrl magUrl, StorageFolder folder, bool isd, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken)) { HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Add("user-agent", "LibrelioWinRT"); var url = magUrl.AbsoluteUrl; if (isd) url = url.Replace("_.", "."); //HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url); //int read = 0; //int offset = 0; //byte[] responseBuffer = new byte[1024]; //var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancelToken); //response.EnsureSuccessStatusCode(); //var length = response.Content.Headers.ContentLength; //cancelToken.ThrowIfCancellationRequested(); //var stream = new InMemoryRandomAccessStream(); //using (var responseStream = await response.Content.ReadAsStreamAsync()) //{ // do // { // cancelToken.ThrowIfCancellationRequested(); // read = await responseStream.ReadAsync(responseBuffer, 0, responseBuffer.Length); // cancelToken.ThrowIfCancellationRequested(); // await stream.AsStream().WriteAsync(responseBuffer, 0, read); // offset += read; // uint val = (uint)(offset * 100 / length); // if (val >= 100) val = 99; // if (val <= 0) val = 1; // progress.Report((int)val); // } // while (read != 0); //} //progress.Report(100); //await stream.FlushAsync(); ////var folder = await AddMagazineFolderStructure(magUrl); ////var folder = await StorageFolder.GetFolderFromPathAsync(folderUrl); var name = magUrl.FullName; if (isd) name = name.Replace("_.", "."); var file = await folder.CreateFileAsync(name, CreationCollisionOption.ReplaceExisting); //using (var protectedStream = await DownloadManager.ProtectPDFStream(stream)) //using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) ////using (var unprotectedStream = await DownloadManager.UnprotectPDFStream(protectedStream)) //{ // await RandomAccessStream.CopyAsync(protectedStream, fileStream.GetOutputStreamAt(0)); // await fileStream.FlushAsync(); //} progress.Report(0); BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(new Uri(url), file); await HandleDownloadAsync(download, true, progress, cancelToken); progress.Report(100); if (cancelToken.IsCancellationRequested) return null; var stream = await download.ResultFile.OpenAsync(FileAccessMode.ReadWrite); var returnStream = new InMemoryRandomAccessStream(); await RandomAccessStream.CopyAsync(stream.GetInputStreamAt(0), returnStream.GetOutputStreamAt(0)); await returnStream.FlushAsync(); var protectedStram = await DownloadManager.ProtectPDFStream(stream); await RandomAccessStream.CopyAndCloseAsync(protectedStram.GetInputStreamAt(0), stream.GetOutputStreamAt(0)); await protectedStram.FlushAsync(); await stream.FlushAsync(); protectedStram.Dispose(); stream.Dispose(); var pdfStream = new MagazineData(); pdfStream.folderUrl = folder.Path + "\\"; pdfStream.stream = returnStream; //var fileHandle = // await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\test\testmagazine.pdf"); //pdfStream.folderUrl = "C:\\Users\\Dorin\\Documents\\Magazines\\wind_355\\"; //pdfStream.stream = await fileHandle.OpenReadAsync(); return pdfStream.stream; }
private async Task<IRandomAccessStream> ResizeStreamAsync(IRandomAccessStream stream, Size size, PhotoOrientation orientation) { var rotation = 0; switch (orientation) { case PhotoOrientation.Rotate180: { rotation = -180; }; break; case PhotoOrientation.Rotate270: { rotation = -270; }; break; case PhotoOrientation.Rotate90: { rotation = -90; }; break; } using (var resizedStream = new InMemoryRandomAccessStream()) { var buffer = new byte[stream.Size].AsBuffer(); stream.Seek(0); await stream.ReadAsync(buffer, buffer.Length, InputStreamOptions.None); var resizeConfiguration = new AutoResizeConfiguration( (uint)(size.Width * size.Height * 4 * 2), size, new Size(0, 0), AutoResizeMode.Automatic, 0.7, ColorSpace.Yuv420); buffer = await JpegTools.AutoResizeAsync(buffer, resizeConfiguration); await resizedStream.WriteAsync(buffer); await resizedStream.FlushAsync(); if (rotation != 0) { resizedStream.Seek(0); var filters = new List<IFilter>() { new RotationFilter(rotation) }; using (var source = new RandomAccessStreamImageSource(resizedStream)) using (var effect = new FilterEffect(source) { Filters = filters }) using (var renderer = new JpegRenderer(effect)) { buffer = await renderer.RenderAsync(); using (var rotatedResizedStream = new InMemoryRandomAccessStream()) { await rotatedResizedStream.WriteAsync(buffer); await rotatedResizedStream.FlushAsync(); return rotatedResizedStream.CloneStream(); } } } else { return resizedStream.CloneStream(); } } }
public Windows.Foundation.IAsyncOperation <bool> FlushAsync() { return(internalStream.FlushAsync()); }
public static async Task<IRandomAccessStream> UnprotectPDFStream(IRandomAccessStream source) { // Create a DataProtectionProvider object. DataProtectionProvider Provider = new DataProtectionProvider(); InMemoryRandomAccessStream unprotectedData = new InMemoryRandomAccessStream(); IOutputStream dest = unprotectedData.GetOutputStreamAt(0); await Provider.UnprotectStreamAsync(source.GetInputStreamAt(0), dest); await unprotectedData.FlushAsync(); unprotectedData.Seek(0); return unprotectedData; }
private async Task ImageUpdate(bool isCommand) { DateTime currentTime = DateTime.UtcNow; // Just incase - stop code being called while photo already in progress if (this.cameraBusy) { return; } this.cameraBusy = true; try { using (Windows.Storage.Streams.InMemoryRandomAccessStream captureStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { await this.mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream); await captureStream.FlushAsync(); #if DEBUG IStorageFile photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync(ImageFilenameLocal, CreationCollisionOption.ReplaceExisting); ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg(); await this.mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile); #endif string azureFilenameLatest = string.Format(this.azureStorageimageFilenameLatestFormat, currentTime); string azureFilenameHistory = string.Format(this.azureStorageImageFilenameHistoryFormat, currentTime); LoggingFields imageInformation = new LoggingFields(); imageInformation.AddDateTime("TakenAtUTC", currentTime); imageInformation.AddBoolean("IsCommand", isCommand); #if DEBUG imageInformation.AddString("LocalFilename", photoFile.Path); #endif imageInformation.AddString("AzureFilenameLatest", azureFilenameLatest); imageInformation.AddString("AzureFilenameHistory", azureFilenameHistory); this.logging.LogEvent("Saving image(s) to Azure storage", imageInformation); // Update the latest image in storage if (!string.IsNullOrWhiteSpace(azureFilenameLatest)) { captureStream.Seek(0); Debug.WriteLine("AzureIoT Hub latest image upload start"); await this.azureIoTHubClient.UploadToBlobAsync(azureFilenameLatest, captureStream.AsStreamForRead()); Debug.WriteLine("AzureIoT Hub latest image upload done"); } // Upload the historic image to storage if (!string.IsNullOrWhiteSpace(azureFilenameHistory)) { captureStream.Seek(0); Debug.WriteLine("AzureIoT Hub historic image upload start"); await this.azureIoTHubClient.UploadToBlobAsync(azureFilenameHistory, captureStream.AsStreamForRead()); Debug.WriteLine("AzureIoT Hub historic image upload done"); } } } catch (Exception ex) { this.logging.LogMessage("Image capture or AzureIoTHub storage upload failed " + ex.Message, LoggingLevel.Error); } finally { this.cameraBusy = false; } }
private async Task LoadImageFromBuffer(IBuffer buffer, BitmapImage bitmap) { using (var stream = new InMemoryRandomAccessStream()) { await stream.WriteAsync(buffer); await stream.FlushAsync(); stream.Seek(0); await bitmap.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () => { try { await bitmap.SetSourceAsync(stream); } catch (Exception ex) { Debug.WriteLine(ex.Message); } }); } }
private async Task LoadImageFromHttpResponse(HttpResponseMessage response, BitmapImage bitmap, string cacheKey) { if (response.IsSuccessStatusCode) { var stream = new InMemoryRandomAccessStream(); using (var content = response.Content) { await content.WriteToStreamAsync(stream); } await stream.FlushAsync(); stream.Seek(0); await bitmap.Dispatcher.RunAsync(CoreDispatcherPriority.Low, async () => { try { await bitmap.SetSourceAsync(stream); // cache image asynchronously, after successful decoding var task = Task.Run(async () => { var buffer = new Windows.Storage.Streams.Buffer((uint)stream.Size); stream.Seek(0); await stream.ReadAsync(buffer, buffer.Capacity, InputStreamOptions.None); stream.Dispose(); await Cache.SetAsync(cacheKey, buffer); }); } catch (Exception ex) { Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, ex.Message); stream.Dispose(); } }); } else { Debug.WriteLine("{0}: {1}", response.RequestMessage.RequestUri, response.StatusCode); } }
public async Task<IRandomAccessStream> DownloadPDFAsync(LibrelioLocalUrl magUrl, StorageFolder folder, IProgress<int> progress = null, CancellationToken cancelToken = default(CancellationToken)) { HttpClient client = new HttpClient(); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, magUrl.Url); int read = 0; int offset = 0; byte[] responseBuffer = new byte[1024]; var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancelToken); response.EnsureSuccessStatusCode(); var length = response.Content.Headers.ContentLength; cancelToken.ThrowIfCancellationRequested(); var stream = new InMemoryRandomAccessStream(); using (var responseStream = await response.Content.ReadAsStreamAsync()) { do { cancelToken.ThrowIfCancellationRequested(); read = await responseStream.ReadAsync(responseBuffer, 0, responseBuffer.Length); cancelToken.ThrowIfCancellationRequested(); await stream.AsStream().WriteAsync(responseBuffer, 0, read); offset += read; uint val = (uint)(offset * 100 / length); if (val >= 100) val = 99; if (val <= 0) val = 1; progress.Report((int)val); } while (read != 0); } progress.Report(100); await stream.FlushAsync(); //var folder = await AddMagazineFolderStructure(magUrl); //var folder = await StorageFolder.GetFolderFromPathAsync(folderUrl); var file = await folder.CreateFileAsync(magUrl.FullName, CreationCollisionOption.ReplaceExisting); using (var protectedStream = await DownloadManager.ProtectPDFStream(stream)) using (var fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.ReadWrite)) //using (var unprotectedStream = await DownloadManager.UnprotectPDFStream(protectedStream)) { await RandomAccessStream.CopyAsync(protectedStream, fileStream.GetOutputStreamAt(0)); await fileStream.FlushAsync(); } var pdfStream = new MagazineData(); pdfStream.folderUrl = folder.Path + "\\"; pdfStream.stream = stream; //var fileHandle = // await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\test\testmagazine.pdf"); //pdfStream.folderUrl = "C:\\Users\\Dorin\\Documents\\Magazines\\wind_355\\"; //pdfStream.stream = await fileHandle.OpenReadAsync(); return pdfStream.stream; }
private async Task ShowVehicleLocations() { var vehicleLocations = await searchVm.GetBusLocations(); while (vehicleCounter > 0) { SearchMap.MapElements.RemoveAt(SearchMap.MapElements.Count - 1); vehicleCounter--; } var inboundBM = new WriteableBitmap(40, 40); await inboundBM.SetSourceAsync(await RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Inbound.png")).OpenReadAsync()); var outboundBM = new WriteableBitmap(40, 40); await outboundBM.SetSourceAsync(await RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Outbound.png")).OpenReadAsync()); foreach (Bus bus in vehicleLocations) { if (bus.direction.Equals("inbound")) { var rotatedImage = inboundBM.RotateFree(bus.busHeading, false); var stream = new InMemoryRandomAccessStream(); await rotatedImage.ToStream(stream, BitmapEncoder.PngEncoderId); var busMarker = new MapIcon { Image = RandomAccessStreamReference.CreateFromStream(stream), CollisionBehaviorDesired = MapElementCollisionBehavior.RemainVisible, Location = new Geopoint(new BasicGeoposition { Latitude = bus.latitude, Longitude = bus.longitude }), NormalizedAnchorPoint = new Point(0.5, 0.5), ZIndex = 99 }; SearchMap.MapElements.Add(busMarker); await stream.FlushAsync(); stream.Dispose(); rotatedImage = null; } else if (bus.direction.Equals("outbound")) { var rotatedImage = outboundBM.RotateFree(bus.busHeading, false); var stream = new InMemoryRandomAccessStream(); await rotatedImage.ToStream(stream, BitmapEncoder.PngEncoderId); var busMarker = new MapIcon { Image = RandomAccessStreamReference.CreateFromStream(stream), CollisionBehaviorDesired = MapElementCollisionBehavior.RemainVisible, Location = new Geopoint(new BasicGeoposition { Latitude = bus.latitude, Longitude = bus.longitude }), NormalizedAnchorPoint = new Point(0.5, 0.5), ZIndex = 99 }; SearchMap.MapElements.Add(busMarker); await stream.FlushAsync(); stream.Dispose(); rotatedImage = null; } vehicleCounter++; } inboundBM = null; outboundBM = null; }
private async Task ImageUpdate(bool isCommand) { DateTime currentTime = DateTime.UtcNow; // Just incase - stop code being called while photo already in progress if (this.cameraBusy) { return; } this.cameraBusy = true; this.displayGpioPin.Write(GpioPinValue.High); // Check that enough time has passed for picture to be taken if ((currentTime - this.imageLastCapturedAtUtc) < this.debounceTimeout) { this.displayOffTimer.Change(this.timerPeriodDetectIlluminated, this.timerPeriodInfinite); return; } this.imageLastCapturedAtUtc = currentTime; try { ImagePrediction imagePrediction; using (Windows.Storage.Streams.InMemoryRandomAccessStream captureStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { this.mediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), captureStream).AsTask().Wait(); captureStream.FlushAsync().AsTask().Wait(); captureStream.Seek(0); IStorageFile photoFile = await KnownFolders.PicturesLibrary.CreateFileAsync(ImageFilename, CreationCollisionOption.ReplaceExisting); ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg(); await this.mediaCapture.CapturePhotoToStorageFileAsync(imageProperties, photoFile); switch (modelType) { case ModelType.Classification: imagePrediction = await this.customVisionClient.ClassifyImageAsync(this.projectId, this.modelPublishedName, captureStream.AsStreamForRead()); break; case ModelType.Detection: imagePrediction = await this.customVisionClient.DetectImageAsync(this.projectId, this.modelPublishedName, captureStream.AsStreamForRead()); break; default: throw new ArgumentException("ModelType Invalid"); } Debug.WriteLine($"Prediction count {imagePrediction.Predictions.Count}"); } JObject telemetryDataPoint = new JObject(); LoggingFields imageInformation = new LoggingFields(); imageInformation.AddDateTime("TakenAtUTC", currentTime); imageInformation.AddBoolean("IsCommand", isCommand); imageInformation.AddDouble("Probability threshold", probabilityThreshold); imageInformation.AddInt32("Predictions", imagePrediction.Predictions.Count); // Display and log the results of the prediction foreach (var prediction in imagePrediction.Predictions) { Debug.WriteLine($" Tag:{prediction.TagName} {prediction.Probability}"); imageInformation.AddDouble($"Tag:{prediction.TagName}", prediction.Probability); } // Post process the predictions based on the type of model switch (modelType) { case ModelType.Classification: // Use only the tags above the specified minimum probability foreach (var prediction in imagePrediction.Predictions) { if (prediction.Probability >= probabilityThreshold) { // Display and log the individual tag probabilities Debug.WriteLine($" Tag valid:{prediction.TagName} {prediction.Probability:0.00}"); imageInformation.AddDouble($"Tag valid:{prediction.TagName}", prediction.Probability); telemetryDataPoint.Add(prediction.TagName, prediction.Probability); } } break; case ModelType.Detection: // Group the tags to get the count, include only the predictions above the specified minimum probability var groupedPredictions = from prediction in imagePrediction.Predictions where prediction.Probability >= probabilityThreshold group prediction by new { prediction.TagName } into newGroup select new { TagName = newGroup.Key.TagName, Count = newGroup.Count(), }; // Display and log the agregated predictions foreach (var prediction in groupedPredictions) { Debug.WriteLine($" Tag valid:{prediction.TagName} {prediction.Count}"); imageInformation.AddInt32($"Tag valid:{prediction.TagName}", prediction.Count); telemetryDataPoint.Add(prediction.TagName, prediction.Count); } break; default: throw new ArgumentException("ModelType Invalid"); } this.logging.LogEvent("Captured image processed by Cognitive Services", imageInformation); try { using (Message message = new Message(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(telemetryDataPoint)))) { Debug.WriteLine(" {0:HH:mm:ss} AzureIoTHubClient SendEventAsync start", DateTime.UtcNow); await this.azureIoTHubClient.SendEventAsync(message); Debug.WriteLine(" {0:HH:mm:ss} AzureIoTHubClient SendEventAsync finish", DateTime.UtcNow); } this.logging.LogEvent("SendEventAsync payload", imageInformation, LoggingLevel.Information); } catch (Exception ex) { imageInformation.AddString("Exception", ex.ToString()); this.logging.LogEvent("SendEventAsync payload", imageInformation, LoggingLevel.Error); } } catch (Exception ex) { this.logging.LogMessage("Camera photo or save failed " + ex.Message, LoggingLevel.Error); } finally { this.displayGpioPin.Write(GpioPinValue.Low); this.cameraBusy = false; } }
public static async Task<BitmapImage> ConvertByteArrayToBitmapImage(byte[] byteValue) { var img = new BitmapImage(); var ras = new InMemoryRandomAccessStream(); await ras.WriteAsync(byteValue.AsBuffer()); await ras.FlushAsync(); ras.Seek(0); img.SetSource(ras); return img; }
private async void DoImageProcessing() { var ps = new InMemoryRandomAccessStream(); while (processImage) { await capturePreview.Source.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateJpeg(), ps); await ps.FlushAsync(); ps.Seek(0); WriteableBitmap bitmap = new WriteableBitmap(424, 240); bitmap.SetSource(ps); int bitmapSize = bitmap.PixelHeight * bitmap.PixelWidth * 4; using (Stream imageStream = bitmap.PixelBuffer.AsStream()) { byte[] bitmapPixelArray = new byte[bitmapSize]; await imageStream.ReadAsync(bitmapPixelArray, 0, bitmapSize); for (int i = 0; i < bitmapSize; i += 4) { selectedPixelFunction(bitmapPixelArray, i); } imageStream.Seek(0, SeekOrigin.Begin); await imageStream.WriteAsync(bitmapPixelArray, 0, bitmapSize); } imageProcess.Source = bitmap; } selectedPixelFunction = null; }
public override object generatePeerImage() { int width = getWidth(); int height = getHeight(); if (width <= 0 || height <= 0) { width = getPreferredW(); height = getPreferredH(); } CodenameOneImage img = new CodenameOneImage(); img.@this(); img.name = "PeerImage: " + element.ToString(); IRandomAccessStream stream = new InMemoryRandomAccessStream(); CanvasBitmap cb = null; SilverlightImplementation.dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => { if (element is WebView) { await ((WebView)element).CapturePreviewToStreamAsync(stream); await stream.FlushAsync(); stream.Seek(0); cb = await CanvasBitmap.LoadAsync(SilverlightImplementation.screen, stream); } else { RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap(); await renderTargetBitmap.RenderAsync(element); byte[] buf = renderTargetBitmap.GetPixelsAsync().AsTask().ConfigureAwait(false).GetAwaiter().GetResult().ToArray(); cb = CanvasBitmap.CreateFromBytes(SilverlightImplementation.screen, buf, width, height, SilverlightImplementation.pixelFormat, SilverlightImplementation.screen.Dpi); } img.image = new CanvasRenderTarget(SilverlightImplementation.screen, cb.SizeInPixels.Width, cb.SizeInPixels.Height, cb.Dpi); img.graphics.destination.drawImage(cb, 0, 0); img.graphics.destination.dispose(); }).AsTask().GetAwaiter().GetResult(); return ui.Image.createImage(img); }
// // TODO: implement code needed to share item from main page // public async void GetSharedData(DataTransferManager sender, DataRequestedEventArgs args) { try { var currentCam = MappableListView.SelectedItem as APIMASH_TomTom.TomTomCameraViewModel; if (currentCam != null) { DataRequestDeferral deferral = args.Request.GetDeferral(); args.Request.Data.Properties.Title = String.Format("TomTom Camera: {0}", currentCam.CameraId); args.Request.Data.Properties.Description = currentCam.Name; // share a file var file = await StorageFile.CreateStreamedFileAsync( String.Format("{0}_{1}.jpg", currentCam.CameraId, DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss")), async stream => { await stream.WriteAsync(currentCam.ImageBytes.AsBuffer()); await stream.FlushAsync(); stream.Dispose(); }, null); args.Request.Data.SetStorageItems(new List<IStorageItem> { file }); // share as bitmap InMemoryRandomAccessStream raStream = new InMemoryRandomAccessStream(); await raStream.WriteAsync(currentCam.ImageBytes.AsBuffer()); await raStream.FlushAsync(); args.Request.Data.SetBitmap(RandomAccessStreamReference.CreateFromStream(raStream)); deferral.Complete(); } else { args.Request.FailWithDisplayText("Select a camera to share its image."); } } catch (Exception ex) { args.Request.FailWithDisplayText(ex.Message); } }
private async Task LoadPendingTiles(TileSource tileSource, string sourceName) { PendingTile pendingTile; while (pendingTiles.TryDequeue(out pendingTile)) { var tile = pendingTile.Tile; var uri = pendingTile.Uri; var image = pendingTile.Image; var extension = Path.GetExtension(uri.LocalPath); if (string.IsNullOrEmpty(extension) || extension == ".jpeg") { extension = ".jpg"; } var cacheKey = string.Format(@"{0}\{1}\{2}\{3}{4}", sourceName, tile.ZoomLevel, tile.XIndex, tile.Y, extension); var cacheItem = await Cache.GetAsync(cacheKey); var loaded = false; if (cacheItem == null || cacheItem.Expires <= DateTime.UtcNow) { loaded = await DownloadImage(tile, image, uri, cacheKey); } if (!loaded && cacheItem != null && cacheItem.Buffer != null) { using (var stream = new InMemoryRandomAccessStream()) { await stream.WriteAsync(cacheItem.Buffer); await stream.FlushAsync(); stream.Seek(0); await LoadImageFromStream(tile, image, stream); } } } Interlocked.Decrement(ref taskCount); }
public override object generatePeerImage() { int width = getWidth(); int height = getHeight(); if (width <= 0 || height <= 0) { width = getPreferredW(); height = getPreferredH(); } if (element.Parent == null) { if (peerImage != null) { return peerImage; } return com.codename1.ui.Image.createImage(width, height); } CodenameOneImage img = new CodenameOneImage(); img.@this(); img.name = "PeerImage: " + element.ToString(); IRandomAccessStream stream = new InMemoryRandomAccessStream(); CanvasBitmap cb = null; using (AutoResetEvent are = new AutoResetEvent(false)) { SilverlightImplementation.dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { if (element is WebView) { try { Task.Delay(TimeSpan.FromTicks(4).Duration()).GetAwaiter().GetResult(); ((WebView)element).CapturePreviewToStreamAsync(stream).AsTask().GetAwaiter().GetResult(); stream.FlushAsync().AsTask().GetAwaiter().GetResult(); stream.Seek(0); Task.Delay(TimeSpan.FromMilliseconds(10)).GetAwaiter().GetResult(); cb = CanvasBitmap.LoadAsync(SilverlightImplementation.screen, stream).AsTask().GetAwaiter().GetResult(); } catch (Exception) { throw; } } else { RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap(); renderTargetBitmap.RenderAsync(element).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); byte[] buf = renderTargetBitmap.GetPixelsAsync().AsTask().ConfigureAwait(false).GetAwaiter().GetResult().ToArray(); cb = CanvasBitmap.CreateFromBytes(SilverlightImplementation.screen, buf, width, height, SilverlightImplementation.pixelFormat, SilverlightImplementation.screen.Dpi); } img.image = new CanvasRenderTarget(SilverlightImplementation.screen, cb.SizeInPixels.Width, cb.SizeInPixels.Height, cb.Dpi); img.graphics.destination.drawImage(cb, 0, 0); img.graphics.destination.dispose(); are.Set(); }).AsTask().ConfigureAwait(false).GetAwaiter().GetResult(); are.WaitOne(); } return com.codename1.ui.Image.createImage(img); // return com.codename1.ui.Image.createImage(width, height); }
private async Task<bool> SaveImage(int id, String folderName, byte[] img) { String fileName = String.Format("{0}.jpg", id); try { using (var streamWeb = new InMemoryRandomAccessStream()) { using (var writer = new DataWriter(streamWeb.GetOutputStreamAt(0))) { writer.WriteBytes(img); await writer.StoreAsync(); var albumPic = await ApplicationData.Current.LocalFolder.CreateFolderAsync(folderName, CreationCollisionOption.OpenIfExists); var file = await albumPic.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists); Debug.WriteLine("Writing file " + folderName + " " + id); using (var raStream = await file.OpenAsync(FileAccessMode.ReadWrite)) { using (var thumbnailStream = streamWeb.GetInputStreamAt(0)) { using (var stream = raStream.GetOutputStreamAt(0)) { await RandomAccessStream.CopyAsync(thumbnailStream, stream); await stream.FlushAsync(); } } await raStream.FlushAsync(); } await writer.FlushAsync(); } await streamWeb.FlushAsync(); } return true; } catch (Exception e) { Debug.WriteLine("Error saving album art: " + e); return false; } }
/// <summary> /// 异步从网络下载图片 /// </summary> /// <param name="outfileName">下载保存到本地的图片文件名</param> /// <param name="downloadUriString">图片uri</param> /// <param name="scaleSize">图片尺寸</param> /// <returns></returns> public static async Task DownloadAndScale(string outfileName, string downloadUriString, Size scaleSize) { try { Uri downLoadingUri = new Uri(downloadUriString);//创建uri对象 HttpClient client = new HttpClient();//实例化httpclient对象 using (var response = await client.GetAsync(downLoadingUri)) { var buffer = await response.Content.ReadAsBufferAsync();//从返回的数据中读取buffer var memoryStream = new InMemoryRandomAccessStream(); await memoryStream.WriteAsync(buffer);//将buffer写入memorystream await memoryStream.FlushAsync();//刷新 var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(memoryStream);//解密文件流 //确定图片大小 var bt = new Windows.Graphics.Imaging.BitmapTransform(); bt.ScaledWidth = (uint)scaleSize.Width; bt.ScaledHeight = (uint)scaleSize.Height; //得到像素数值 var pixelProvider = await decoder.GetPixelDataAsync( decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, bt, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.ColorManageToSRgb); //下面保存图片 // Now that we have the pixel data, get the destination file var localFolder = ApplicationData.Current.LocalFolder; //var resultsFolder = await localFolder.CreateFolderAsync("Results", CreationCollisionOption.OpenIfExists); var scaledFile = await localFolder.CreateFileAsync(outfileName, CreationCollisionOption.ReplaceExisting); using (var scaledFileStream = await scaledFile.OpenAsync(FileAccessMode.ReadWrite)) { var encoder = await BitmapEncoder.CreateAsync( BitmapEncoder.JpegEncoderId, scaledFileStream); var pixels = pixelProvider.DetachPixelData(); encoder.SetPixelData( decoder.BitmapPixelFormat, decoder.BitmapAlphaMode, (uint)scaleSize.Width, (uint)scaleSize.Height, decoder.DpiX, decoder.DpiY, pixels ); await encoder.FlushAsync(); } } } catch (Exception) { Debug.WriteLine("工具,图片异常"); } }
private async void OnTap(object sender, TappedRoutedEventArgs e) { ImageEncodingProperties imageProperties = ImageEncodingProperties.CreateJpeg(); var fPhotoStream = new InMemoryRandomAccessStream(); await mediaCapture.CapturePhotoToStreamAsync(imageProperties, fPhotoStream); await fPhotoStream.FlushAsync(); fPhotoStream.Seek(0); var _bmp = new BitmapImage(); _bmp.SetSource(fPhotoStream); PreviewImage.Source = _bmp; }
public async Task<string> GetImageAsBase64Encoded() { // Adapted from // http social.msdn.microsoft.com/Forums/wpapps/en-US/.../image-to-base64-encoding [Win Phone 7, 2010] and // <same site> /sharing-a-writeablebitmap and // www.charlespetzold.com/blog/2012/08/WritableBitmap-Pixel-Arrays-in-CSharp-and-CPlusPlus.html // example in WebcamPage.xaml.cs string results = ""; try { //using (Stream stream = App.CurrentPatient.ImageWriteableBitmap.PixelBuffer.AsStream()) using (Stream stream = ImageWriteableBitmap.PixelBuffer.AsStream()) //There are 4 bytes per pixel. { byte[] pixels = await ConvertStreamToByteArray(stream); // Now render the object in a known format, e.g., jpeg: //InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream(); IRandomAccessStream ms = new InMemoryRandomAccessStream(); // If calling from a synchronous function, add AsTask().ConfigureAwait(false) to avoid hanging UI thread // If image as optionally cropped is over 1.5Mp, then apply aggressive compression to get it to that size (approximately) double quality = 1.0; //Max quality, the default. For jpeg, 1.0 - quality = compression ratio UInt64 totalPixels = (ulong)ImageWriteableBitmap.PixelWidth * (ulong)ImageWriteableBitmap.PixelHeight; if (totalPixels > 1500000L) quality = Math.Round(((double)1500000.0 / (double)totalPixels), 2, MidpointRounding.AwayFromZero); // for debug purposes, round quality to 2 fractional digits // For encoding options, wee msdn.microsoft.com/en-us/library/windows/apps/jj218354.aspx "How to use encoding options". var encodingOptions = new BitmapPropertySet(); var qualityValue = new BitmapTypedValue(quality, Windows.Foundation.PropertyType.Single); encodingOptions.Add("ImageQuality", qualityValue); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, ms, encodingOptions); //.AsTask().ConfigureAwait(false); /* BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.BmpEncoderId, ms); */ encoder.SetPixelData( BitmapPixelFormat.Bgra8, //Rgba8, //Bgra8, BitmapAlphaMode.Straight, // .Ignore (uint)ImageWriteableBitmap.PixelWidth,//(uint)App.CurrentPatient.ImageWriteableBitmap.PixelWidth, (uint)ImageWriteableBitmap.PixelHeight,//(uint)App.CurrentPatient.ImageWriteableBitmap.PixelHeight, 96.0, 96.0, pixels); await encoder.FlushAsync(); //.AsTask().ConfigureAwait(false); byte[] jpgEncoded = await ConvertMemoryStreamToByteArray(ms); results = Convert.ToBase64String(jpgEncoded); await ms.FlushAsync(); // cleanup } } catch (Exception ex) { Debug.WriteLine("Error when encoding image: " + ex.Message); } return results; }
private async Task RenderFirstPDFPageAsync(string docUri, double height, double width) { try { var pdfFile = await StorageFile.GetFileFromPathAsync(docUri).AsTask().ConfigureAwait(false); var pdfDocument = await PdfDocument.LoadFromFileAsync(pdfFile).AsTask().ConfigureAwait(false); if (pdfDocument?.PageCount > 0) { using (var pdfPage = pdfDocument.GetPage(0)) { var renderOptions = GetPdfRenderOptions(pdfPage, height, width); if (renderOptions != null) { IsMultiPage = pdfDocument.PageCount > 1; // LOLLO TODO MAYBE deal with multi pages with tiff too ? using (var stream = new InMemoryRandomAccessStream()) { await pdfPage.RenderToStreamAsync(stream, renderOptions).AsTask().ConfigureAwait(false); await stream.FlushAsync().AsTask().ConfigureAwait(false); await DisplayImageFileAsync(stream).ConfigureAwait(false); } } } } } catch (Exception ex) { await Logger.AddAsync(ex.ToString(), Logger.ForegroundLogFilename).ConfigureAwait(false); } }
private async static void UriSourcePropertyChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e) { Debug.WriteLine("我被触发了"); StorageCachedImage image = d as StorageCachedImage; string i = e.NewValue as string; int k = i.IndexOf("image"); string imagePath = i.Substring(k + 7); string uri = App.Uri + "public/images/" + imagePath; Debug.WriteLine(uri); Uri imageUri = new Uri(uri); HttpClient client = new HttpClient(); var response = await client.GetAsync(imageUri); var buffer = await response.Content.ReadAsBufferAsync(); var memoryStream = new InMemoryRandomAccessStream(); await memoryStream.WriteAsync(buffer); await memoryStream.FlushAsync(); await image.SetSourceAsync(memoryStream); }