/// <summary> /// This is the click handler for the 'Solution' button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void bookmarkBtn_Click(object sender, RoutedEventArgs e) { InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream(); await webView8.CapturePreviewToStreamAsync(ms); //Create a small thumbnail int longlength = 180, width = 0, height = 0; double srcwidth = webView8.ActualWidth, srcheight = webView8.ActualHeight; double factor = srcwidth / srcheight; if (factor < 1) { height = longlength; width = (int)(longlength * factor); } else { width = longlength; height = (int)(longlength / factor); } BitmapSource small = await resize(width, height, ms); BookmarkItem item = new BookmarkItem(); item.Title = webView8.DocumentTitle; item.PageUrl = webView8.Source; item.Preview = small; bookmarks.Add(item); }
public static async Task <Windows.UI.Xaml.Media.Imaging.BitmapImage> GetBitmapAsync(byte[] data) { if (data is null) { return(null); } var bitmapImage = new Windows.UI.Xaml.Media.Imaging.BitmapImage(); using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { using (var writer = new Windows.Storage.Streams.DataWriter(stream)) { writer.WriteBytes(data); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); } stream.Seek(0); await bitmapImage.SetSourceAsync(stream); } return(bitmapImage); }
public static async Task<IRandomAccessStream> ConvertToRandomAccessStream(Stream source) { Stream streamToConvert = null; if (!source.CanRead) throw new Exception("The source cannot be read."); if (!source.CanSeek) { var memStream = new MemoryStream(); await source.CopyToAsync(memStream); streamToConvert = memStream; } else { streamToConvert = source; } var reader = new DataReader(streamToConvert.AsInputStream()); streamToConvert.Position = 0; await reader.LoadAsync((uint) streamToConvert.Length); var buffer = reader.ReadBuffer((uint) streamToConvert.Length); var randomAccessStream = new InMemoryRandomAccessStream(); var outputStream = randomAccessStream.GetOutputStreamAt(0); await outputStream.WriteAsync(buffer); await outputStream.FlushAsync(); return randomAccessStream; }
internal static Bitmap FromStream(Stream stream) { Bitmap bitmap = null; Task.Run(async () => { using (var raStream = new InMemoryRandomAccessStream()) { await stream.CopyToAsync(raStream.AsStream()); var decoder = await BitmapDecoder.CreateAsync(raStream); var pixelData = await decoder.GetPixelDataAsync(); var width = (int)decoder.OrientedPixelWidth; var height = (int)decoder.OrientedPixelHeight; const PixelFormat format = PixelFormat.Format32bppArgb; var bytes = pixelData.DetachPixelData(); bitmap = new Bitmap(width, height, format); var data = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, format); Marshal.Copy(bytes, 0, data.Scan0, bytes.Length); bitmap.UnlockBits(data); } }).Wait(); return bitmap; }
public object Convert(object value, Type targetType, object parameter, string language) { if (value != null) { byte[] bytes = (byte[])value; BitmapImage myBitmapImage = new BitmapImage(); if (bytes.Count() > 0) { InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream(); DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0)); writer.WriteBytes(bytes); writer.StoreAsync().GetResults(); myBitmapImage.SetSource(stream); } else { myBitmapImage.UriSource = new Uri("ms-appx:///Assets/firstBackgroundImage.jpg"); } return myBitmapImage; } else { return new BitmapImage(); } }
public static async Task <byte[]> TranscodeImageFile(WriteableBitmap wb) { using (var ras = wb.PixelBuffer.AsStream().AsRandomAccessStream()) { System.Diagnostics.Debug.WriteLine("1"); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(ras); System.Diagnostics.Debug.WriteLine("2"); var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); System.Diagnostics.Debug.WriteLine("3"); BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder); encoder.BitmapTransform.ScaledWidth = 320; encoder.BitmapTransform.ScaledHeight = 240; System.Diagnostics.Debug.WriteLine("4"); await encoder.FlushAsync(); System.Diagnostics.Debug.WriteLine("5"); var outbuff = new byte[memStream.Size]; System.Diagnostics.Debug.WriteLine("6"); await memStream.WriteAsync(outbuff.AsBuffer()); System.Diagnostics.Debug.WriteLine("7"); return(outbuff); } }
private async void GetBijinPicture() { var date = DateTime.Now; var url = "http://www.bijint.com/jp/tokei_images/" + date.ToString("HHmm") + ".jpg"; HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/jp/"); using (var strm = await client.GetStreamAsync(new Uri(url))) { // BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、 // InMemoryRandomAccessStreamへソースストリームをコピーする InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream(); var output = ims.GetOutputStreamAt(0); await RandomAccessStream.CopyAsync(strm.AsInputStream(), output); // BitmapImageへソースを設定し、Imageコントロールで表示させる var bitmap = new BitmapImage(); bitmap.SetSource(ims); image.Source = bitmap; // Save用にbyte配列に保存 ims.Seek(0); imageBuffer = new byte[ims.Size]; IBuffer ibuffer = imageBuffer.AsBuffer(); await ims.ReadAsync(ibuffer, (uint)ims.Size, InputStreamOptions.None); } }
/// <summary> /// Continuously look for a QR code /// NOTE: this method won't work if recording is enabled ('hey Cortana, start recording' thing). /// </summary> public static async Task<string> ReadAsync(CancellationToken token = default(CancellationToken)) { var mediaCapture = new MediaCapture(); await mediaCapture.InitializeAsync(); await mediaCapture.AddVideoEffectAsync(new MrcVideoEffectDefinition(), MediaStreamType.Photo); var reader = new BarcodeReader(); reader.Options.TryHarder = false; while (!token.IsCancellationRequested) { var imgFormat = ImageEncodingProperties.CreateJpeg(); using (var ras = new InMemoryRandomAccessStream()) { await mediaCapture.CapturePhotoToStreamAsync(imgFormat, ras); var decoder = await BitmapDecoder.CreateAsync(ras); using (var bmp = await decoder.GetSoftwareBitmapAsync()) { Result result = await Task.Run(() => { var source = new SoftwareBitmapLuminanceSource(bmp); return reader.Decode(source); }); if (!string.IsNullOrEmpty(result?.Text)) return result.Text; } } await Task.Delay(DelayBetweenScans); } return null; }
public byte[] DrawStrokeOnImageBackground(IReadOnlyList<InkStroke> strokes, byte[] backgroundImageBuffer) { var stmbuffer = new InMemoryRandomAccessStream(); stmbuffer.AsStreamForWrite().AsOutputStream().WriteAsync(backgroundImageBuffer.AsBuffer()).AsTask().Wait(); CanvasDevice device = CanvasDevice.GetSharedDevice(); var canbit = CanvasBitmap.LoadAsync(device, stmbuffer, 96).AsTask().Result; CanvasRenderTarget renderTarget = new CanvasRenderTarget(device, canbit.SizeInPixels.Width, canbit.SizeInPixels.Height, 96); using (var ds = renderTarget.CreateDrawingSession()) { ds.Clear(Colors.Transparent); if (backgroundImageBuffer != null) { ds.DrawImage(canbit); } ds.DrawInk(strokes); } var stm = new InMemoryRandomAccessStream(); renderTarget.SaveAsync(stm, CanvasBitmapFileFormat.Png).AsTask().Wait(); var readfrom = stm.GetInputStreamAt(0).AsStreamForRead(); var ms = new MemoryStream(); readfrom.CopyTo(ms); var outputBuffer = ms.ToArray(); return outputBuffer; }
public async static Task<Uri> ToQrDataUri(this ISdp sdp, int width, int height) { var qrCodeWriter = new QRCodeWriter(); var bitMatrix = qrCodeWriter.encode(sdp.ToString(), ZXing.BarcodeFormat.QR_CODE, width, height); using (var canvasRenderTarget = new CanvasRenderTarget(CanvasDevice.GetSharedDevice(), 500, 500, 96)) { using (var drawingSession = canvasRenderTarget.CreateDrawingSession()) { for (var y = 0; y < height; y++) { for (var x = 0; x < width; x++) { drawingSession.DrawRectangle(x, y, 1, 1, bitMatrix.get(x, y) ? Color.FromArgb(0, 0, 0, 0) : Color.FromArgb(255, 255, 255, 255)); } } } using (var inMemoryRandomAccessStream = new InMemoryRandomAccessStream()) { await canvasRenderTarget.SaveAsync(inMemoryRandomAccessStream, CanvasBitmapFileFormat.Png); inMemoryRandomAccessStream.Seek(0); var buffer = new byte[inMemoryRandomAccessStream.Size]; await inMemoryRandomAccessStream.ReadAsync(buffer.AsBuffer(), (uint)inMemoryRandomAccessStream.Size, InputStreamOptions.None); return new Uri($"data:image/png;base64,{Convert.ToBase64String(buffer)}"); } } }
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 void Page_Loaded(object sender, RoutedEventArgs e) { await InitializeQrCode(); var imgProp = new ImageEncodingProperties { Subtype = "BMP", Width = 600, Height = 800 }; var bcReader = new BarcodeReader(); while (true) { var stream = new InMemoryRandomAccessStream(); await _mediaCapture.CapturePhotoToStreamAsync(imgProp, stream); stream.Seek(0); var wbm = new WriteableBitmap(600, 800); await wbm.SetSourceAsync(stream); var result = bcReader.Decode(wbm); if (result != null) { var msgbox = new MessageDialog(result.Text); await msgbox.ShowAsync(); } } }
async void BeginReadCCTV() { IsBeginRead = true; ISExit = false; tblCCTV cctvinfo=null; await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { cctvinfo = this.DataContext as tblCCTV; }); // client=new HttpClient(); while (!ISExit) { try { Uri uri = new Uri("http://192.192.161.3/" + cctvinfo.REF_CCTV_ID.Trim() + ".jpg?" + rnd.Next(), UriKind.Absolute); using (httpClient = new HttpClient()) { httpClient.Timeout = TimeSpan.FromSeconds(0.5); var contentBytes = await httpClient.GetByteArrayAsync(uri); var ims = new InMemoryRandomAccessStream(); var dataWriter = new DataWriter(ims); dataWriter.WriteBytes(contentBytes); await dataWriter.StoreAsync(); //ims.seak 0 ims.Seek(0 ); await Dispatcher.RunAsync( Windows.UI.Core.CoreDispatcherPriority.Normal,()=> { BitmapImage bitmap = new BitmapImage(); bitmap.SetSource(ims ); this.imgCCTV.Source = bitmap; imginx = (imginx + 1) % 90000; this.RunFrameRate.Text = imginx.ToString(); }); } } catch (Exception ex) { // this.textBlock1.Text = ex.Message; } // BitmapImage img = new BitmapImage(); // img.SetSource(stream); } }
public async Task<BitmapSource> LoadImageAsync(Stream imageStream, Uri uri) { if (imageStream == null) { return null; } var stream = new InMemoryRandomAccessStream(); imageStream.CopyTo(stream.AsStreamForWrite()); stream.Seek(0); BitmapImage bitmap = new BitmapImage(); await bitmap.SetSourceAsync(stream); // convert to a writable bitmap so we can get the PixelBuffer back out later... // in case we need to edit and/or re-encode the image. WriteableBitmap bmp = new WriteableBitmap(bitmap.PixelHeight, bitmap.PixelWidth); stream.Seek(0); bmp.SetSource(stream); List<Byte> allBytes = new List<byte>(); byte[] buffer = new byte[4000]; int bytesRead = 0; while ((bytesRead = await imageStream.ReadAsync(buffer, 0, 4000)) > 0) { allBytes.AddRange(buffer.Take(bytesRead)); } DataContainerHelper.Instance.WriteableBitmapToStorageFile(bmp, uri); return bmp; }
async Task<WriteableBitmap> ResizeImage(WriteableBitmap baseWriteBitmap, uint width, uint height) { Stream stream = baseWriteBitmap.PixelBuffer.AsStream(); byte[] pixels = new byte[(uint)stream.Length]; await stream.ReadAsync(pixels, 0, pixels.Length); var inMemoryRandomStream = new InMemoryRandomAccessStream(); var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, inMemoryRandomStream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)baseWriteBitmap.PixelWidth, (uint)baseWriteBitmap.PixelHeight, 96, 96, pixels); await encoder.FlushAsync(); var transform = new BitmapTransform { ScaledWidth = width, ScaledHeight = height }; inMemoryRandomStream.Seek(0); var decoder = await BitmapDecoder.CreateAsync(inMemoryRandomStream); var pixelData = await decoder.GetPixelDataAsync( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage); var sourceDecodedPixels = pixelData.DetachPixelData(); var inMemoryRandomStream2 = new InMemoryRandomAccessStream(); var encoder2 = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, inMemoryRandomStream2); encoder2.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, width, height, 96, 96, sourceDecodedPixels); await encoder2.FlushAsync(); inMemoryRandomStream2.Seek(0); var bitmap = new WriteableBitmap((int)width, (int)height); await bitmap.SetSourceAsync(inMemoryRandomStream2); return bitmap; }
public async static void GetImageSize(this Stream imageStream) { var image = new BitmapImage(); byte[] imageBytes = Convert.FromBase64String(imageStream.ToBase64String()); MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length); ms.Write(imageBytes, 0, imageBytes.Length); using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream()) { using (DataWriter writer = new DataWriter(stream.GetOutputStreamAt(0))) { try { writer.WriteBytes(imageBytes); await writer.StoreAsync(); } catch (Exception) { // ignored } } try { await image.SetSourceAsync(stream); } catch (Exception) { // ignored } } ImageSize = new Size(image.PixelWidth, image.PixelHeight); }
// TODO: 一分ごとに画像と名前を取得する private async void GetBijinInfo() { var date = this.Current; getKawaii(this.path + this.Current.ToString("HHmm")); var url = "http://www.bijint.com/" + Path + "/tokei_images/" + date.ToString("HHmm") + ".jpg"; HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/" + path); using (var strm = await client.GetStreamAsync(new Uri(url))) { // BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、 // InMemoryRandomAccessStreamへソースストリームをコピーする InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream(); var output = ims.GetOutputStreamAt(0); await RandomAccessStream.CopyAsync(strm.AsInputStream(), output); // BitmapImageへソースを設定し、Imageコントロールで表示させる var bitmap = new BitmapImage(); bitmap.SetSource(ims); this.Image = bitmap; } var html = await client.GetStringAsync("http://www.bijint.com/" + Path + "/cache/" + date.ToString("HHmm") + ".html"); var lines = html.Split('\n').Select(input => input.Trim()).Where(input => input != "\r" || input != "").ToList(); var nameLineIndex = lines.IndexOf("<thead>") + 2; var nameLine = lines[nameLineIndex]; var temp = nameLine.Substring(0, nameLine.Length - 5); var lastEnd = temp.LastIndexOf('>'); this.Subtitle = temp.Substring(lastEnd + 1); }
public async Task<BitmapImage> GetBijinPicture(string Path) { var date = DateTime.Now; var url = "http://www.bijint.com/" + Path + "/tokei_images/" + date.ToString("HHmm") + ".jpg"; HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Referrer = new Uri("http://www.bijint.com/" + Path); BitmapImage bitmap; using (var strm = await client.GetStreamAsync(new Uri(url))) { // BitmapImageインスタンスへはStream型をそのまま読み込ませることができないため、 // InMemoryRandomAccessStreamへソースストリームをコピーする InMemoryRandomAccessStream ims = new InMemoryRandomAccessStream(); var output = ims.GetOutputStreamAt(0); await RandomAccessStream.CopyAsync(strm.AsInputStream(), output); // BitmapImageへソースを設定し、Imageコントロールで表示させる bitmap = new BitmapImage(); bitmap.SetSource(ims); } return bitmap; //var html = await client.GetStringAsync("http://www.bijint.com/kobe/cache/" + date.ToString("HHmm") + ".html"); //this.html.NavigateToString(html); }
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 async void ProccesImage(StorageFile imageFile) { var data = await FileIO.ReadBufferAsync(imageFile); // create a stream from the file var ms = new InMemoryRandomAccessStream(); var dw = new DataWriter(ms); dw.WriteBuffer(data); await dw.StoreAsync(); ms.Seek(0); // find out how big the image is, don't need this if you already know var bm = new BitmapImage(); await bm.SetSourceAsync(ms); // create a writable bitmap of the right size var wb = new WriteableBitmap(bm.PixelWidth, bm.PixelHeight); ms.Seek(0); // load the writable bitpamp from the stream await wb.SetSourceAsync(ms); Bitmap bmp = (Bitmap)wb; //var filter1 = Grayscale.CommonAlgorithms.BT709; //bmp = filter1.Apply(bmp); wb = (WriteableBitmap)bmp; var file = await this.WriteableBitmapToStorageFile(wb, FileFormat.Jpeg); }
private async void OnDeferredImageRequestedHandler(DataProviderRequest request) { // In this delegate we provide updated Bitmap data using delayed rendering. if (_imageFile != null) { // If the delegate is calling any asynchronous operations it needs to acquire // the deferral first. This lets the system know that you are performing some // operations that might take a little longer and that the call to SetData // could happen after the delegate returns. Once you acquired the deferral object // you must call Complete on it after your final call to SetData. DataProviderDeferral deferral = request.GetDeferral(); InMemoryRandomAccessStream inMemoryStream = new InMemoryRandomAccessStream(); // Make sure to always call Complete when finished with the deferral. try { // Decode the image and re-encode it at 50% width and height. IRandomAccessStream imageStream = await _imageFile.OpenAsync(FileAccessMode.Read); BitmapDecoder imageDecoder = await BitmapDecoder.CreateAsync(imageStream); BitmapEncoder imageEncoder = await BitmapEncoder.CreateForTranscodingAsync(inMemoryStream, imageDecoder); imageEncoder.BitmapTransform.ScaledWidth = (uint)(imageDecoder.OrientedPixelWidth * 0.5); imageEncoder.BitmapTransform.ScaledHeight = (uint)(imageDecoder.OrientedPixelHeight * 0.5); await imageEncoder.FlushAsync(); request.SetData(RandomAccessStreamReference.CreateFromStream(inMemoryStream)); } finally { deferral.Complete(); } } }
public async Task<BitmapImage> Base64ToBitmapImage(string base64String) { BitmapImage img = new BitmapImage(); if (string.IsNullOrEmpty(base64String)) return img; using (var ims = new InMemoryRandomAccessStream()) { byte[] bytes = Convert.FromBase64String(base64String); base64String = ""; using (DataWriter dataWriter = new DataWriter(ims)) { dataWriter.WriteBytes(bytes); bytes = null; await dataWriter.StoreAsync(); ims.Seek(0); await img.SetSourceAsync(ims); //not in RC return img; } } }
public async Task Should_read_correctly_formatted_stream() { using (var input = new InMemoryRandomAccessStream()) using (var expectedData = TestFiles.Read("IO.HashedBlockStream.Content.bin")) { await CopyData(input, "IO.HashedBlockStream.bin"); input.Seek(0); expectedData.Seek(0); using (var actualData = await HashedBlockFileFormat.Read(input)) { Assert.Equal(expectedData.Size, (ulong)actualData.Length); var actual = new byte[1024]; var expected = WindowsRuntimeBuffer.Create(actual.Length); while (true) { expected = await expectedData.ReadAsync(expected); var read = await actualData.ReadAsync(actual, 0, actual.Length); Assert.Equal(expected.Length, (uint)read); if (read == 0) break; Assert.Equal(expected.ToArray(), actual.Take(read)); } } } }
public static async Task <byte[]> TranscodeImageFile(byte[] data) { using (IRandomAccessStream stream = data.AsBuffer().AsStream().AsRandomAccessStream()) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream); var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var outstream = new InMemoryRandomAccessStream(); BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder); encoder.BitmapTransform.ScaledWidth = 320; encoder.BitmapTransform.ScaledHeight = 240; await encoder.FlushAsync(); memStream.Seek(0); await RandomAccessStream.CopyAsync(memStream, outstream); memStream.Dispose(); var outbuff = new byte[outstream.Size]; await outstream.WriteAsync(outbuff.AsBuffer()); return(outbuff); } }
private async void Button_Click_2(object sender, RoutedEventArgs e) { var mem = new InMemoryRandomAccessStream(); var enc = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, mem); int width = 140, height = 140; int plane = 4; byte[] data = new byte[width * height * plane]; int offset = 0; for (int y = 0; y < width; y++) { for (int x = 0; x < height; x++) { data[offset + 0] = 0xFF; // R data[offset + 1] = 0x00; // G data[offset + 2] = 0x00; // B data[offset + 3] = 0xFF; // Alpha offset += 4; } } enc.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Straight, (uint)width, (uint)height, 96, 96, data); await enc.FlushAsync(); BitmapImage bmp = new BitmapImage(); bmp.SetSource(mem); image1.Source = bmp; }
public async static Task<IRandomAccessStream> AsRandomAccessStreamAsync(this Stream stream) { Stream streamToConvert = null; if (!stream.CanRead) { throw new Exception("Cannot read the source stream-"); } if (!stream.CanSeek) { MemoryStream memoryStream = new MemoryStream(); await stream.CopyToAsync(memoryStream); streamToConvert = memoryStream; } else { streamToConvert = stream; } DataReader dataReader = new DataReader(streamToConvert.AsInputStream()); streamToConvert.Position = 0; await dataReader.LoadAsync((uint)streamToConvert.Length); IBuffer buffer = dataReader.ReadBuffer((uint)streamToConvert.Length); InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream(); IOutputStream outputstream = randomAccessStream.GetOutputStreamAt(0); await outputstream.WriteAsync(buffer); await outputstream.FlushAsync(); return randomAccessStream; }
public async Task<byte[]> ConvertToGrayScale(byte[] imageBytes, int height, int width) { using (InMemoryRandomAccessStream rasStream = new InMemoryRandomAccessStream()) { await rasStream.WriteAsync(imageBytes.AsBuffer()); var decoder = await BitmapDecoder.CreateAsync(rasStream); var pixelData = await decoder.GetPixelDataAsync(); var pixels = pixelData.DetachPixelData(); if (_filter == null) _filter = new ImageFilter(); await _filter.ToGrayScale(pixels.AsBuffer()); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, rasStream); encoder.SetPixelData(decoder.BitmapPixelFormat, BitmapAlphaMode.Ignore, (uint)width, (uint)height, decoder.DpiX, decoder.DpiY, pixels); await encoder.FlushAsync(); using (BinaryReader br = new BinaryReader(rasStream.AsStreamForRead())) { rasStream.Seek(0); return br.ReadBytes((int)rasStream.AsStreamForRead().Length); } } }
public static async Task<IRandomAccessStream> RenderToRandomAccessStream(this UIElement element) { var rtb = new RenderTargetBitmap(); await rtb.RenderAsync(element); IBuffer pixelBuffer = await rtb.GetPixelsAsync(); byte[] pixels = pixelBuffer.ToArray(); // Useful for rendering in the correct DPI DisplayInformation displayInformation = DisplayInformation.GetForCurrentView(); var stream = new InMemoryRandomAccessStream(); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)rtb.PixelWidth, (uint)rtb.PixelHeight, displayInformation.RawDpiX, displayInformation.RawDpiY, pixels); await encoder.FlushAsync(); stream.Seek(0); return stream; }
private async Task RenderUIElement(FrameworkElement elm, string fileName, int width, int height) { await System.Threading.Tasks.Task.Delay(TimeSpan.FromSeconds(1)); using (InMemoryRandomAccessStream ms = new InMemoryRandomAccessStream()) { var renderTargetBitmap = new RenderTargetBitmap(); await renderTargetBitmap.RenderAsync(elm); var pixels = await renderTargetBitmap.GetPixelsAsync(); var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi; var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, ms); encoder.SetPixelData( BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)renderTargetBitmap.PixelWidth, (uint)renderTargetBitmap.PixelHeight, logicalDpi, logicalDpi, pixels.ToArray()); await encoder.FlushAsync(); await X.Services.Image.Service.Instance.GenerateResizedImageAsync(width, elm.ActualWidth, elm.ActualHeight, ms, fileName + ".png", Services.Image.Service.location.TileFolder, height); } }
public async Task<string> RenderToBase64(UIElement element) { RenderTargetBitmap rtb = new RenderTargetBitmap(); await rtb.RenderAsync(element); var pixelBuffer = await rtb.GetPixelsAsync(); var pixels = pixelBuffer.ToArray(); // Useful for rendering in the correct DPI var displayInformation = DisplayInformation.GetForCurrentView(); var stream = new InMemoryRandomAccessStream(); var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, (uint)rtb.PixelWidth, (uint)rtb.PixelHeight, displayInformation.RawDpiX, displayInformation.RawDpiY, pixels); await encoder.FlushAsync(); stream.Seek(0); // read bytes var bytes = new byte[stream.Size]; await stream.AsStream().ReadAsync(bytes, 0, bytes.Length); // create base64 return Convert.ToBase64String(bytes); }
/// <summary> /// Asynchronously saves the <paramref name="photo" /> given to the camera roll album. /// </summary> /// <param name="photo">Photo to save.</param> /// <returns>Image with thumbnail.</returns> /// <exception cref="ArgumentNullException"><paramref name="photo"/> is <see langword="null"/>.</exception> public async Task<IThumbnailedImage> SaveResultToCameraRollAsync(ICapturedPhoto photo) { if (photo == null) { throw new ArgumentNullException("photo"); } Tracing.Trace("StorageService: Trying to save picture to the Camera Roll."); Picture cameraRollPicture; string name = this.GeneratePhotoName(); using (InMemoryRandomAccessStream stream = new InMemoryRandomAccessStream()) { // Convert image to JPEG format and rotate in accordance with the original photo orientation. Tracing.Trace("StorageService: Converting photo to JPEG format. Size: {0}x{1}, Rotation: {2}", photo.Width, photo.Height, photo.Rotation); byte[] pixelData = await photo.DetachPixelDataAsync(); BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, stream); encoder.BitmapTransform.Rotation = photo.Rotation; encoder.BitmapTransform.Flip = photo.Flip; encoder.IsThumbnailGenerated = true; encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, photo.Width, photo.Height, Constants.DefaultDpiX, Constants.DefaultDpiY, pixelData); await encoder.FlushAsync(); cameraRollPicture = this.lazyMediaLibrary.Value.SavePictureToCameraRoll(name, stream.AsStream()); } Tracing.Trace("StorageService: Saved to Camera Roll as {0}", name); return new MediaLibraryThumbnailedImage(cameraRollPicture); }
public object Convert(object value, Type targetType, object parameter, string language) { if (value != null && value is byte[]) { //WriteableBitmap bitmap = new WriteableBitmap(100, 100); //System.IO.Stream bitmapStream = null; //bitmapStream = bitmap.PixelBuffer.AsStream(); //bitmapStream.Position = 0; //bitmapStream.Write(value as byte[], 0, (value as byte[]).Length); //bitmapStream.Flush(); InMemoryRandomAccessStream randomAccessStream = new InMemoryRandomAccessStream(); DataWriter writer = new DataWriter(randomAccessStream.GetOutputStreamAt(0)); writer.WriteBytes(value as byte[]); var x = writer.StoreAsync().AsTask().Result; BitmapImage image = new BitmapImage(); image.SetSource(randomAccessStream); return image; } return null; }
//</SnippetVertices> /// <summary> /// Fixes issue in API where textures are not saved correctly /// </summary> /// <param name="modelStream">3dmodel.model data</param> /// <returns></returns> private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream) { XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead()); var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var writer = new Windows.Storage.Streams.DataWriter(outputStream); writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; writer.WriteString("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); var text = xmldoc.ToString(); // ensure that content type is set correctly // texture content can be either png or jpg var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\""); writer.WriteString(replacedText); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); return(outputStream); }
public static async Task<IBuffer> SaveAsPngIntoBufferAsync(this Canvas canvas, double _scaleFactor, int dpiForImage = 200) { //string currentresolution = Window.Current.Bounds.Width * scaleFactor + "*" + Window.Current.Bounds.Height * scaleFactor; RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap(); await renderTargetBitmap.RenderAsync(canvas); var pixels = await renderTargetBitmap.GetPixelsAsync(); using (IRandomAccessStream stream = new InMemoryRandomAccessStream()) { var encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); byte[] bytes = pixels.ToArray(); await CoreWindow.GetForCurrentThread().Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { encoder.SetPixelData(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Ignore, (uint)(canvas.ActualWidth * _scaleFactor), (uint)(canvas.ActualHeight * _scaleFactor), dpiForImage, dpiForImage, bytes); }); await encoder.FlushAsync(); stream.Seek(0); var buffer = WindowsRuntimeBuffer.Create((int)stream.Size); await stream.ReadAsync(buffer, (uint)stream.Size, InputStreamOptions.None); return buffer; } }
public async Task <Windows.Storage.Streams.InMemoryRandomAccessStream> GetStreamUWP(double width, double height) { var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); await RenderToStreamAsync(stream, width, height); return(stream); }
private async Task WriteImage() { if (currentImageIndex == -1) { return; } try { await CreateFolder(); StorageFile outputFile = await projectFolder.CreateFileAsync(filesNames.ElementAt(currentImageIndex), CreationCollisionOption.ReplaceExisting); var stream = (await outputFile.OpenStreamForWriteAsync()).AsRandomAccessStream(); Guid encoderId; if (filesNames.ElementAt(currentImageIndex).Contains(".jpg")) { encoderId = Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId; } var inputStream = await files.ElementAt(currentImageIndex).OpenStreamForReadAsync(); BitmapDecoder decoder = await BitmapDecoder.CreateAsync(inputStream.AsRandomAccessStream()); var inputProperties = decoder.BitmapProperties; var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); BitmapEncoder encoder2 = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder); WriteImageMetadata(encoder2, inputProperties); await encoder2.FlushAsync(); memStream.Seek(0); stream.Seek(0); stream.Size = 0; await RandomAccessStream.CopyAsync(memStream, stream); memStream.Dispose(); stream.Dispose(); inputStream.Dispose(); if (latitude.Text != null) { await GeotagHelper.SetGeotagAsync(outputFile, myLocation); } } catch (Exception err) { switch (err.HResult) { case unchecked ((int)0x88982F41): // WINCODEC_ERR_PROPERTYNOTSUPPORTED // The file format does not support this property. break; default: break; } } }
/// <summary> /// あとでファイルとして保存できるように共有Bitmapの情報を保存しておく. /// </summary> /// <param name="inStream"></param> /// <returns></returns> private async Task KeepSharedBitmapInfoAsync(Windows.Storage.Streams.IRandomAccessStreamWithContentType inStream) { var decoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(inStream); this.fileName = DateTimeOffset.UtcNow.Ticks.ToString() + decoder.DecoderInformation.FileExtensions[0]; this.imageStream = new InMemoryRandomAccessStream(); inStream.Seek(0); await Windows.Storage.Streams.RandomAccessStream.CopyAsync(inStream, imageStream); }
private async void SaveSoftwareBitmapToFile(SoftwareBitmap softwareBitmap) { using (var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) // (IRandomAccessStream stream = await outputFile.OpenAsync(FileAccessMode.ReadWrite)) { // Create an encoder with the desired format BitmapEncoder encoder = await BitmapEncoder.CreateAsync(BitmapEncoder.JpegEncoderId, memStream); // Set the software bitmap encoder.SetSoftwareBitmap(softwareBitmap); // Set additional encoding parameters, if needed encoder.BitmapTransform.ScaledWidth = 320; encoder.BitmapTransform.ScaledHeight = 240; //encoder.BitmapTransform.Rotation = Windows.Graphics.Imaging.BitmapRotation.Clockwise90Degrees; encoder.BitmapTransform.InterpolationMode = BitmapInterpolationMode.Fant; encoder.IsThumbnailGenerated = true; try { await encoder.FlushAsync(); // UploadImage // An array containing the decoded image data, which could be modified before being displayed IBuffer buff = new Windows.Storage.Streams.Buffer((uint)memStream.Size); memStream.Seek(0); IBuffer c = await memStream.ReadAsync(buff, buff.Capacity, InputStreamOptions.None); //WindowsRuntimeBufferExtensions.ToArray http://cctvapi.azurewebsites.net //await UploadImage("http://localhost:56407/Api/File/", buff.ToArray()) ; http://peopledetectionapiapp.azurewebsites.net/swagger/ui/index //await UploadImage("http://cctvapi.azurewebsites.net/Api/File/", buff.ToArray()); await UploadImage("http://peopledetectionapiapp.azurewebsites.net/swagger/ui/index", buff.ToArray()); } catch (Exception err) { switch (err.HResult) { case unchecked ((int)0x88982F81): //WINCODEC_ERR_UNSUPPORTEDOPERATION // If the encoder does not support writing a thumbnail, then try again // but disable thumbnail generation. encoder.IsThumbnailGenerated = false; break; default: throw err; } } if (encoder.IsThumbnailGenerated == false) { await encoder.FlushAsync(); } } }
private async void buttonTakePhotoClick(object sender, RoutedEventArgs e) { if (capturePreview.Source == null) { return; } // プレビューに付けた MediaCapture オブジェクトを取り出す Windows.Media.Capture.MediaCapture capture = capturePreview.Source; // 保存する画像ファイルのフォーマット (pngファイルを指定) var imageProperties = Windows.Media.MediaProperties.ImageEncodingProperties.CreatePng(); // 撮影する。撮影した画像の stream が返ってくる。 // 自前のコードで WriteableBitmap に変換 using (var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { try { await capture.CapturePhotoToStreamAsync(imageProperties, memStream); // キャプチャ開始から撮影までの間に許可を取り消されると、ここで例外が出る // 「指定されたファイル ハンドルへのアクセスが取り消されました。 (HRESULT からの例外: 0x80070326)」 } catch (Exception ex) { ShowRequestMessageAsync(ex); return; } captureImage.Source = await memStream.ToWriteableBitmap(); } // 撮影する。素直にいったんファイルに落とす方法 //StorageFile file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync("test.png", CreationCollisionOption.GenerateUniqueName); //try //{ // await capture.CapturePhotoToStorageFileAsync(imageProperties, file); // // キャプチャ開始から撮影までの間に許可を取り消されると、ここで例外が出る // // 「指定されたファイル ハンドルへのアクセスが取り消されました。 (HRESULT からの例外: 0x80070326)」 //} //catch (Exception ex) //{ // ShowRequestMessageAsync(ex); // return; //} //using (var stream = await file.OpenReadAsync()) //{ // var bi = new BitmapImage(); // bi.SetSource(stream); // captureImage.Source = bi; //} }
private async Task LoadBrushAsync() { using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { await ImageSource.ToStream(stream, BitmapEncoder.BmpEncoderId); stream.Seek(0); ImageEffectsBrush.LoadImageFromStream(stream); } }
private CDTrackStream(string deviceID, int startSector, int endSector) { DeviceID = deviceID; StartSector = startSector; EndSector = endSector; WriteDataIndex = 0; ReadDataIndex = 0; internalStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); }
private async Task <Windows.Storage.Streams.IRandomAccessStream> toStream(Windows.Storage.Streams.IBuffer ibuffer) { var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var outputStream = stream.GetOutputStreamAt(0); var datawriter = new Windows.Storage.Streams.DataWriter(outputStream); datawriter.WriteBuffer(ibuffer); await datawriter.StoreAsync(); await outputStream.FlushAsync(); return(stream); }
public async Task <WriteableBitmap> GetImageSourceAsync() { WriteableBitmap bmp = new WriteableBitmap(ImageBitmap.PixelWidth, ImageBitmap.PixelHeight); using (var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { await ImageBitmap.ToStream(stream, BitmapEncoder.BmpEncoderId); stream.Seek(0); await bmp.SetSourceAsync(stream); } return(bmp); }
private async void MyBooksSelectionChanged(object sender, RoutedEventArgs e) { var selected = flipMyBooks.SelectedItem as EbookViewModel; if (selected == null) { return; } ProgressRingBooks.IsActive = true; ObservableCollection <ImageSource> pdf = null; if (gvImages.ItemsSource != null) { pdf = gvImages.ItemsSource as ObservableCollection <ImageSource>; gvImages.SelectedIndex = 0; pdf.Clear(); } else { pdf = new ObservableCollection <ImageSource>(); gvImages.ItemsSource = pdf; } var query = new GetAllEbookPartsQuery(); await query.ExecuteAsync(OAuthSettings.AccessToken, selected.Id, selected.PartCount, async (sourceStream) => { var stream = new InMemoryRandomAccessStream(); await sourceStream.CopyToAsync(stream.AsStreamForWrite()); var doc = await PdfDocument.LoadFromStreamAsync(stream); for (uint i = 0; i < doc.PageCount; ++i) { var bmpStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); await doc.GetPage(i).RenderToStreamAsync(bmpStream); Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { var bmp = new BitmapImage(); bmp.SetSource(bmpStream); pdf.Add(bmp); }); } }); ProgressRingBooks.IsActive = false; }
private async Task LoadMyEbooksAsync() { List <EbookViewModel> viewModels = new List <EbookViewModel>(); var ebooks = await new GetMyEbooksQuery().ExecuteAsync(OAuthSettings.AccessToken); foreach (var ebook in ebooks) { var img = new BitmapImage(); var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); stream.GetOutputStreamAt(0).AsStreamForWrite().Write(ebook.Thumbnail, 0, ebook.Thumbnail.Length); await img.SetSourceAsync(stream); viewModels.Add(new EbookViewModel(ebook, img)); } flipMyBooks.ItemsSource = viewModels; }
/// <summary> /// 指定範囲のキャプチャ画像をSoftwareBitmap型として得る /// </summary> /// <param name="left">キャプチャ範囲の左端端x座標</param> /// <param name="top">キャプチャ範囲の左端端y座標</param> /// <param name="height">キャプチャ範囲の高さ</param> /// <param name="width">キャプチャ範囲の幅</param> /// <returns>指定された範囲のキャプチャ画像</returns> public static async Task <SoftwareBitmap> CaptureAsSoftwareBitmap(int left, int top, int height, int width) { //ビットマップの保持領域を確保 Bitmap partialCapture = new Bitmap(width, height); //描画インターフェイスの設定 Graphics draw = Graphics.FromImage(partialCapture); //画面全体をコピーする draw.CopyFromScreen( left, top, 0, 0, partialCapture.Size ); //解放 draw.Dispose(); MemoryStream memStream = new MemoryStream(); partialCapture.Save(memStream, ImageFormat.Bmp); SoftwareBitmap softwareBitmap; using (var randomAccessStream = new UwpInMemoryRandomAccessStream()) { using (var outputStream = randomAccessStream.GetOutputStreamAt(0)) using (var writer = new UwpDataWriter(outputStream)) { writer.WriteBytes(memStream.ToArray()); await writer.StoreAsync(); await outputStream.FlushAsync(); } // IRandomAccessStreamをSoftwareBitmapに変換 // (ここはUWP APIのデコーダーを使う) var decoder = await UwpBitmapDecoder.CreateAsync(randomAccessStream); softwareBitmap = await decoder.GetSoftwareBitmapAsync(UwpBitmapPixelFormat.Bgra8, UwpBitmapAlphaMode.Premultiplied); } return(softwareBitmap); }
void BitmapRequested(CustomMapTileDataSource sender, MapTileBitmapRequestedEventArgs args) { var deferral = args.Request.GetDeferral(); IRandomAccessStreamReference referenceStream; double lat, lon = 0; int pixelX, pixelY = 0; Microsoft.MapPoint.TileSystem.TileXYToPixelXY(args.X, args.Y, out pixelX, out pixelY); Microsoft.MapPoint.TileSystem.PixelXYToLatLong(pixelX, pixelY, args.ZoomLevel, out lat, out lon); BasicGeoposition northWest = new BasicGeoposition { Latitude = lat, Longitude = lon }; Microsoft.MapPoint.TileSystem.PixelXYToLatLong(pixelX + (int)sizeOfMapTile, pixelY + (int)sizeOfMapTile, args.ZoomLevel, out lat, out lon); BasicGeoposition southEast = new BasicGeoposition { Latitude = lat, Longitude = lon }; GeoboundingBox tileBox = new GeoboundingBox(northWest, southEast); if (tileBox.CollidesWith(PathBox)) { if (PathCache.pointInPolygon(northWest.Longitude, northWest.Latitude) && PathCache.pointInPolygon(southEast.Longitude, southEast.Latitude) && PathCache.pointInPolygon(northWest.Longitude, southEast.Latitude) && PathCache.pointInPolygon(southEast.Longitude, northWest.Latitude)) { referenceStream = RandomAccessStreamReference.CreateFromStream(InTile); } else { var cutter = new Windows.Storage.Streams.InMemoryRandomAccessStream(); cutTile(cutter, pixelX, pixelY, args.ZoomLevel); referenceStream = RandomAccessStreamReference.CreateFromStream(cutter); } } else { referenceStream = RandomAccessStreamReference.CreateFromStream(OutTile); } args.Request.PixelData = referenceStream; deferral.Complete(); }
private async Task updateImage(Image cameraImage, string url) { // Download the image into memory as a stream System.Net.Http.HttpClient client = new System.Net.Http.HttpClient(); System.Net.Http.HttpResponseMessage imageResponse = await client.GetAsync(url); InMemoryRandomAccessStream randomAccess = new Windows.Storage.Streams.InMemoryRandomAccessStream(); DataWriter writer = new Windows.Storage.Streams.DataWriter(randomAccess.GetOutputStreamAt(0)); writer.WriteBytes(await imageResponse.Content.ReadAsByteArrayAsync()); await writer.StoreAsync(); BitmapImage bit = new BitmapImage(); await bit.SetSourceAsync(randomAccess); cameraImage.Source = bit; }
// </SnippetCreateSoftwareBitmapFromSurface> // <SnippetTranscodeImageFile> private async void TranscodeImageFile(StorageFile imageFile) { using (IRandomAccessStream fileStream = await imageFile.OpenAsync(FileAccessMode.ReadWrite)) { BitmapDecoder decoder = await BitmapDecoder.CreateAsync(fileStream); var memStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); BitmapEncoder encoder = await BitmapEncoder.CreateForTranscodingAsync(memStream, decoder); encoder.BitmapTransform.ScaledWidth = 320; encoder.BitmapTransform.ScaledHeight = 240; await encoder.FlushAsync(); memStream.Seek(0); fileStream.Seek(0); fileStream.Size = 0; await RandomAccessStream.CopyAsync(memStream, fileStream); memStream.Dispose(); } }
private async Task <IRandomAccessStream> FixTextureContentType(IRandomAccessStream modelStream) { XDocument xmldoc = XDocument.Load(modelStream.AsStreamForRead()); var outputStream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var writer = new Windows.Storage.Streams.DataWriter(outputStream); writer.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8; writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; var text = xmldoc.ToString(); var replacedText = text.Replace("contenttype=\"\"", "contenttype=\"image/png\""); writer.WriteString(replacedText); await writer.StoreAsync(); await writer.FlushAsync(); writer.DetachStream(); return(outputStream); }
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 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 void Dispose() { internalStream.Dispose(); internalStream = null; }
public async Task CaptureThumbnail(Windows.Storage.Streams.InMemoryRandomAccessStream ms) { }
private async Task <string> ExecuteCommandLineString(string CommandString) { const string CommandLineProcesserExe = "c:\\windows\\system32\\cmd.exe"; const uint CommandStringResponseBufferSize = 8192; string currentDirectory = "C:\\"; StringBuilder textOutput = new StringBuilder((int)CommandStringResponseBufferSize); uint bytesLoaded = 0; if (string.IsNullOrWhiteSpace(CommandString)) { return(""); } var commandLineText = CommandString.Trim(); var standardOutput = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var standardError = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var options = new Windows.System.ProcessLauncherOptions { StandardOutput = standardOutput, StandardError = standardError }; try { var args = "/C \"cd \"" + currentDirectory + "\" & " + commandLineText + "\""; var result = await Windows.System.ProcessLauncher.RunToCompletionAsync(CommandLineProcesserExe, args, options); //First write std out using (var outStreamRedirect = standardOutput.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(outStreamRedirect)) { while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } new System.Threading.ManualResetEvent(false).WaitOne(10); if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } } } //Then write std err using (var errStreamRedirect = standardError.GetInputStreamAt(0)) { using (var dataReader = new Windows.Storage.Streams.DataReader(errStreamRedirect)) { while ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } new System.Threading.ManualResetEvent(false).WaitOne(10); if ((bytesLoaded = await dataReader.LoadAsync(CommandStringResponseBufferSize)) > 0) { textOutput.Append(dataReader.ReadString(bytesLoaded)); } } } return(textOutput.ToString()); } catch (UnauthorizedAccessException uex) { return("ERROR - " + uex.Message + "\n\nCmdNotEnabled"); } catch (Exception ex) { return("ERROR - " + ex.Message + "\n"); } }
private async void Stream_Click1(object sender, RoutedEventArgs e) { byte[] startSequence = { 0, 0, 0, 1, 0x27, 0x4d }; var options = new PropertySet(); //options.Add("framerate", "25"); //options.Add("vcodec", "copy"); _ws = new StreamWebSocket(); await _ws.ConnectAsync(new Uri(wsuri.Text, UriKind.Absolute)); bool isStarted = false; bool isCreated = false; var stream = new Windows.Storage.Streams.InMemoryRandomAccessStream(); var output = stream.GetOutputStreamAt(0); var writer = new DataWriter(output); int maxdelay = 10; int delay = maxdelay; int index = 0; DataReader reader = new DataReader(_ws.InputStream); do { var loaded = await reader.LoadAsync(10 * 1024); var buf = reader.ReadBuffer(loaded); if (!isStarted) { isStarted = true; var signature = buf.ToArray(); index = Helpers.FindSequence(signature, 0, startSequence); if (index == -1) { Debug.WriteLine("signature not found, continuing"); continue; } buf = signature.AsBuffer(index, signature.Length - index); Debug.WriteLine("buffer created"); //await output.WriteAsync(buf); writer.WriteBuffer(buf); } else { //await output.WriteAsync(buf); //await output.FlushAsync(); writer.WriteBuffer(buf); } await writer.StoreAsync(); if (delay > 0) { delay--; Debug.Write("B"); //Debug.WriteLine(stream.Position); continue; } //delay = maxdelay; //Debug.Write("."); try { //await output.WriteAsync(buf); if (!isCreated) { isCreated = true; //stream.Seek((ulong)0); var decoder = FFmpegInterop.FFmpegInteropMSS.CreateFFmpegInteropMSSFromStream( stream, false, false, options); if (decoder == null) { Debug.WriteLine("decoder was null, will retry"); continue; } var source = decoder.GetMediaStreamSource(); source.Closed += Source_Closed; source.Starting += Source_Starting; source.SampleRequested += Source_SampleRequested; source.SampleRendered += Source_SampleRendered; //source.BufferTime = TimeSpan.FromSeconds(0.2); media.SetMediaStreamSource(source); media.Play(); } } catch (Exception err) { Debug.WriteLine(err.ToString()); stream.Dispose(); reader.Dispose(); return; } }while (true); }
public void StartAdvertisement( string serviceName, bool autoAccept, bool preferGO, string pin, IList <WiFiDirectServiceConfigurationMethod> configMethods, WiFiDirectServiceStatus status, uint customStatus, string serviceInfo, string deferredServiceInfo, IList <String> prefixList ) { ThrowIfDisposed(); // Create Advertiser object for the service // NOTE: service name is internally limited to up to 255 bytes in UTF-8 encoding // Valid characters include alpha-numeric, '.', '-', and any multi-byte character // characters a-z, A-Z are case-insensitive when discovering services WiFiDirectServiceAdvertiser advertiser = new WiFiDirectServiceAdvertiser(serviceName); // Auto-accept services will connect without interaction from advertiser // NOTE: if the config method used for a connection requires a PIN, then the advertiser will have to accept the connection advertiser.AutoAcceptSession = autoAccept; // Set the Group Owner intent to a large value so that the advertiser will try to become the group owner (GO) // NOTE: The GO of a P2P connection can connect to multiple clients while the client can connect to a single GO only advertiser.PreferGroupOwnerMode = preferGO; // Default status is "Available", but services may use a custom status code (value > 1) if applicable advertiser.ServiceStatus = status; advertiser.CustomServiceStatusCode = customStatus; // Service information can be up to 65000 bytes. // Service Seeker may explicitly discover this by specifying a short buffer that is a subset of this buffer. // If seeker portion matches, then entire buffer is returned, otherwise, the service information is not returned to the seeker // This sample uses a string for the buffer but it can be any data if (serviceInfo != null && serviceInfo.Length > 0) { using (var tempStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { using (var serviceInfoDataWriter = new Windows.Storage.Streams.DataWriter(tempStream)) { serviceInfoDataWriter.WriteString(serviceInfo); advertiser.ServiceInfo = serviceInfoDataWriter.DetachBuffer(); } } } else { advertiser.ServiceInfo = null; } // This is a buffer of up to 144 bytes that is sent to the seeker in case the connection is "deferred" (i.e. not auto-accepted) // This buffer will be sent when auto-accept is false, or if a PIN is required to complete the connection // For the sample, we use a string, but it can contain any data if (deferredServiceInfo != null && deferredServiceInfo.Length > 0) { using (var tempStream = new Windows.Storage.Streams.InMemoryRandomAccessStream()) { using (var deferredSessionInfoDataWriter = new Windows.Storage.Streams.DataWriter(tempStream)) { deferredSessionInfoDataWriter.WriteString(deferredServiceInfo); advertiser.DeferredSessionInfo = deferredSessionInfoDataWriter.DetachBuffer(); } } } else { advertiser.DeferredSessionInfo = null; } // The advertiser supported configuration methods // Valid values are PIN-only (either keypad entry, display, or both), or PIN (keypad entry, display, or both) and WFD Services default // WFD Services Default config method does not require explicit PIN entry and offers a more seamless connection experience // Typically, an advertiser will support PIN display (and WFD Services Default), and a seeker will connect with either PIN entry or WFD Services Default if (configMethods != null) { advertiser.PreferredConfigurationMethods.Clear(); foreach (var configMethod in configMethods) { advertiser.PreferredConfigurationMethods.Add(configMethod); } } // Advertiser may also be discoverable by a prefix of the service name. Must explicitly specify prefixes allowed here. if (prefixList != null && prefixList.Count > 0) { advertiser.ServiceNamePrefixes.Clear(); foreach (var prefix in prefixList) { advertiser.ServiceNamePrefixes.Add(prefix); } } // For this sample, we wrap the advertiser in our own object which handles the advertiser events AdvertisementWrapper advertiserWrapper = new AdvertisementWrapper(advertiser, this, pin); AddAdvertiser(advertiserWrapper); RootPage.NotifyUser("Starting service...", NotifyType.StatusMessage); try { // This may fail if the driver is unable to handle the request or if services is not supported // NOTE: this must be called from the UI thread of the app advertiser.Start(); } catch (Exception ex) { RootPage.NotifyUser(String.Format(CultureInfo.InvariantCulture, "Failed to start service: {0}", ex.Message), NotifyType.ErrorMessage); throw; } }
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); }