private async void button_Click(object sender, RoutedEventArgs e)
        {
            CameraCaptureUI captureUI = new CameraCaptureUI();
            captureUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
            captureUI.PhotoSettings.CroppedSizeInPixels = new Size(200, 200);

            StorageFile photo = await captureUI.CaptureFileAsync(CameraCaptureUIMode.Photo);

            if (photo == null)
            {
                // User cancelled photo capture
                return;
            }
            IRandomAccessStream stream = await photo.OpenAsync(FileAccessMode.Read);
            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
            SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
            SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap,
            BitmapPixelFormat.Bgra8,
            BitmapAlphaMode.Premultiplied);

            SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
            await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

            imageControl.Source = bitmapSource;

        }
Example #2
0
        public async Task<SoftwareBitmapSource> ConvertToSoftwareBitmapSource(SoftwareBitmap bitmap)
        {
            SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
            await bitmapSource.SetBitmapAsync(bitmap);

            return bitmapSource;
        }
Example #3
0
        private async void BrowsePhotoButton_Click(object sender, RoutedEventArgs e)
        {
            FileOpenPicker openPicker = new FileOpenPicker();
            openPicker.ViewMode = PickerViewMode.Thumbnail;
            openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
            openPicker.FileTypeFilter.Add(".jpg");
            openPicker.FileTypeFilter.Add(".jpeg");
            openPicker.FileTypeFilter.Add(".png");

            StorageFile file = await openPicker.PickSingleFileAsync();
            if (file != null)
            {
                photoStream = await camera.ConvertToStream(file);
                photoBitmap = await camera.ConvertToSoftwareBitmap(photoStream);
                photoBitmapSource = await camera.ConvertToSoftwareBitmapSource(photoBitmap);
            }
        }
        /// <summary>
        /// Trigger file picker and image evaluation
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void ButtonRun_Click(object sender, RoutedEventArgs e)
        {
            ButtonRun.IsEnabled   = false;
            UIPreviewImage.Source = null;
            StatusBlock.Text      = "Loading image...";
            try
            {
                // Trigger file picker to select an image file
                FileOpenPicker fileOpenPicker = new FileOpenPicker();
                fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
                StorageFile selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();

                SoftwareBitmap softwareBitmap;
                using (IRandomAccessStream stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
                {
                    // Create the decoder from the stream
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);

                    // Get the SoftwareBitmap representation of the file in BGRA8 format
                    softwareBitmap = await decoder.GetSoftwareBitmapAsync();

                    softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }

                // Display the image
                SoftwareBitmapSource imageSource = new SoftwareBitmapSource();
                await imageSource.SetBitmapAsync(softwareBitmap);

                UIPreviewImage.Source = imageSource;

                // Encapsulate the image within a VideoFrame to be bound and evaluated
                VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);

                await EvaluateVideoFrameAsync(inputImage);
            }
            catch (Exception ex)
            {
                StatusBlock.Text    = $"error: {ex.Message}";
                ButtonRun.IsEnabled = true;
            }
        }
Example #5
0
        /// <summary>
        /// Configure an IFrameSource from a StorageFile or MediaCapture instance to produce optionally a specified format of frame
        /// </summary>
        /// <param name="source"></param>
        /// <param name="inputImageDescriptor"></param>
        /// <returns></returns>
        private async Task ConfigureFrameSourceAsync(object source, ISkillFeatureImageDescriptor inputImageDescriptor = null)
        {
            await m_lock.WaitAsync();

            {
                // Reset bitmap rendering component
                UIProcessedPreview.Source = null;
                m_renderTargetFrame       = null;
                m_processedBitmapSource   = new SoftwareBitmapSource();
                UIProcessedPreview.Source = m_processedBitmapSource;

                // Clean up previous frame source
                if (m_frameSource != null)
                {
                    m_frameSource.FrameArrived -= FrameSource_FrameAvailable;
                    var disposableFrameSource = m_frameSource as IDisposable;
                    if (disposableFrameSource != null)
                    {
                        // Lock disposal based on frame source consumers
                        disposableFrameSource.Dispose();
                    }
                }

                // Create new frame source and register a callback if the source fails along the way
                m_frameSource = await FrameSourceFactory.CreateFrameSourceAsync(
                    source,
                    (sender, message) =>
                {
                    NotifyUser(message);
                },
                    inputImageDescriptor);

                // TODO: Workaround for a bug in ObjectDetectorBinding when binding consecutively VideoFrames with Direct3DSurface and SoftwareBitmap
                m_binding = await m_skill.CreateSkillBindingAsync() as ObjectDetectorBinding;
            }
            m_lock.Release();

            // If we obtained a valid frame source, start it
            if (m_frameSource != null)
            {
                m_frameSource.FrameArrived += FrameSource_FrameAvailable;
                await m_frameSource.StartAsync();
            }
        }
Example #6
0
        private async void SoftwareBitmapToWriteableBitmap(SoftwareBitmap softwareBitmap)
        {
            softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight);

            // CHANGE THIS SNIPPET NAME - LEAVING NOW TO AVOID RISK OF BUILD BREAK
            // <SnippetSoftwareBitmapToWriteableBitmap>
            if (softwareBitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 ||
                softwareBitmap.BitmapAlphaMode == BitmapAlphaMode.Straight)
            {
                softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
            }

            var source = new SoftwareBitmapSource();
            await source.SetBitmapAsync(softwareBitmap);

            // Set the source of the Image control
            imageControl.Source = source;
            // </SnippetSoftwareBitmapToWriteableBitmap>
        }
Example #7
0
        private async Task <bool> Classify(Image image)
        {
            var bitmapSource = new SoftwareBitmapSource();

            editPreview.Source = bitmapSource;
            var histogram = await ComputeHistogramWithDisplay(image, bitmapSource, TimeSpan.FromMilliseconds(500));

            var emptyOutputs = new List <double>()
            {
                0, 0, 0, 0, 0, 0
            };

            _classifier.ChangeData(histogram, emptyOutputs);
            var classification = _classifier.GetClassification();

            ClassTextBlock.Text      = Folders.PlantNames[classification.Item1] + " Class";
            ConfidenceTextBlock.Text = classification.Item2 + "% Confidence";
            return(true);
        }
Example #8
0
        private async void ScaleRainbowButton_Click(object sender, RoutedEventArgs e)
        {
            SoftwareBitmap tempSB;
            double         scale = DisplayInformation.GetForCurrentView().RawPixelsPerViewPixel;

            int renderTB_Width  = 200;
            int renderTB_Height = 100;
            int newWidth        = g704_softwareBitmap.PixelWidth;
            int newHeight       = g704_softwareBitmap.PixelHeight;

            // Step 1 :
            // Create RenderTargetBitmap by ColorRectangle.
            // Don't worry about both width and height of ColorRectangle.
            RenderTargetBitmap renderTargetBitmap = new RenderTargetBitmap();

            ColorRectangle.Fill = MyColorHelper.GetRainbowBrush();
            await renderTargetBitmap.RenderAsync(ColorRectangle, renderTB_Width, renderTB_Height);

            // Step 2 :
            // Get IBuffer from RenderTargetBitmap,
            IBuffer ib = await renderTargetBitmap.GetPixelsAsync();

            // Step 3 :
            // Create a temporary SoftwareBitmap which is based on current scale
            tempSB = SoftwareBitmap.CreateCopyFromBuffer(ib, BitmapPixelFormat.Bgra8,
                                                         (int)(renderTB_Width * scale), (int)(renderTB_Height * scale));
            tempSB = SoftwareBitmap.Convert(tempSB, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

            // Step 4 :
            // Adjust to the same size as g704 image
            tempSB = Resize(tempSB, newWidth, newHeight);

            // Step 5 :
            // Assign this temp image pixels to g704 image
            g704_softwareBitmap = SoftwareBitmap.Convert(g704_softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Straight);
            AssignPixelValues(g704_softwareBitmap, tempSB);
            g704_softwareBitmap = SoftwareBitmap.Convert(g704_softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

            var source = new SoftwareBitmapSource();
            await source.SetBitmapAsync(g704_softwareBitmap);

            G704.Source = source;
        }
Example #9
0
        /// <summary>
        /// Trigger take photo and recognize the emotion present in the image
        /// </summary>
        private async void ButtonRun_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // Prepare and capture photo
                var lowLagCapture = await mediaCapture.PrepareLowLagPhotoCaptureAsync(ImageEncodingProperties.CreateUncompressed(MediaPixelFormat.Bgra8));

                var capturedPhoto = await lowLagCapture.CaptureAsync();

                var softwareBitmap = capturedPhoto.Frame.SoftwareBitmap;

                await lowLagCapture.FinishAsync();

                // Display the captured image
                var imageSource      = new SoftwareBitmapSource();
                var displayableImage = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                await imageSource.SetBitmapAsync(displayableImage);

                PreviewImage.Source = imageSource;

                // Crop, Resize and Convert to gray scale the image (FERPlus model expects a grayscale image of 64x64 pixels)
                var rgbaImage     = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Rgba8, BitmapAlphaMode.Premultiplied);
                var mindim        = Math.Min(rgbaImage.PixelWidth, rgbaImage.PixelHeight);
                var croppedBitmap = CropSoftwareBitmap(rgbaImage,
                                                       rgbaImage.PixelWidth / 2 - mindim / 2,
                                                       rgbaImage.PixelHeight / 2 - mindim / 2,
                                                       mindim, mindim);
                var scaledBitmap    = ResizeSoftwareBitmap(croppedBitmap, 64, 64);
                var grayscaleBitmap = SoftwareBitmap.Convert(scaledBitmap, BitmapPixelFormat.Gray8, BitmapAlphaMode.Ignore);

                // Finally, Predict the dominat emotion present in the image (assuming that the image predominatly shows a face)
                VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(grayscaleBitmap);
                await Task.Run(async() =>
                {
                    // Evaluate the image
                    await EvaluateVideoFrameAsync(inputImage);
                });
            }
            catch (Exception ex)
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => StatusBlock.Text = $"error: {ex.Message}");
            }
        }
Example #10
0
        private async Task CapturePhotoAsync()
        {
            var lowlagCapture = await _mediaCapture.PrepareLowLagPhotoCaptureAsync(ImageEncodingProperties.CreateUncompressed(MediaPixelFormat.Bgra8));

            var capturedPhoto = await lowlagCapture.CaptureAsync();

            var softwareBitmap       = capturedPhoto.Frame.SoftwareBitmap;
            var softwareBitmapSource = new SoftwareBitmapSource();
            await softwareBitmapSource.SetBitmapAsync(SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied));

            await lowlagCapture.FinishAsync();


            _isPreviewing = false;

            /*var filename = "pb" + DateTime.Now.ToString("ssmmHHddMMyy") + ".bmp";
             * var file = await savePicturesFolder.CreateFileAsync(filename, CreationCollisionOption.ReplaceExisting);
             * await _mediaCapture.CapturePhotoToStorageFileAsync(ImageEncodingProperties.CreateJpeg(), file);
             *
             * IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
             * BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
             * SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
             * SoftwareBitmapSource softwareBitmapSource = new SoftwareBitmapSource();
             * await softwareBitmapSource.SetBitmapAsync(SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied));*/

            activepicture.Source = softwareBitmapSource;
            images.Add(softwareBitmap);
            await CleanupCameraAsync();

            if (picstaken < totpics)
            {
                picstaken++;
                activepicture = (Image)this.FindName("image" + picstaken.ToString());
                await StartPreviewAsync();
            }
            else
            {
                complete = true;
                StartButton.Visibility = Visibility.Visible;
                dispatchTimer.Stop();
                mergePhotos();
            }
        }
        public static void BindSoftwareBitmapToImageControl(Microsoft.UI.Xaml.Controls.Image imageControl, SoftwareBitmap softwareBitmap)
        {
            SoftwareBitmap displayBitmap = softwareBitmap;

            //Image control only accepts BGRA8 encoding and Premultiplied/no alpha channel. This checks and converts
            //the SoftwareBitmap we want to bind.
            if (displayBitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 ||
                displayBitmap.BitmapAlphaMode != BitmapAlphaMode.Premultiplied)
            {
                displayBitmap = SoftwareBitmap.Convert(displayBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
            }

            // get software bitmap souce
            var source = new SoftwareBitmapSource();

            source.SetBitmapAsync(displayBitmap).GetAwaiter();
            // draw the input image
            imageControl.Source = source;
        }
Example #12
0
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {
            Frame rootFrame = Window.Current.Content as Frame;

            SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility =
                rootFrame.CanGoBack ?
                AppViewBackButtonVisibility.Visible :
                AppViewBackButtonVisibility.Collapsed;

            base.OnNavigatedTo(e);
            var softwareBitmap = SoftwareBitmap.Convert((SoftwareBitmap)e.Parameter, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

            bitmap       = softwareBitmap;
            alteredImage = bitmap;
            var source = new SoftwareBitmapSource();
            await source.SetBitmapAsync(softwareBitmap);

            imageControl.Source = source;
        }
Example #13
0
        private async void file2SoftwareBitmapSource(StorageFile file, int index = 0, bool isAddImage = false)
        {
            if (!isAddImage)
            {
                IStorageFolder applicationFolder = ApplicationData.Current.TemporaryFolder;
                await file.CopyAndReplaceAsync(await applicationFolder.CreateFileAsync(file.Name, CreationCollisionOption.ReplaceExisting));
            }

            SoftwareBitmapSource source = new SoftwareBitmapSource();
            SoftwareBitmap sb = null;
            using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
            {
                BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
                SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                sb = softwareBitmap;
            }
            await source.SetBitmapAsync(sb);
            imageList.Insert(index, new CommunityImageList { imgUri = source, imgName = file.Name, imgPath = file.Path, imgAppPath = "ms-appdata:///Temp/" + file.Name });
        }
Example #14
0
        private async void mostrarFoto(StorageFile file)
        {
            IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);

            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);

            SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();

            SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

            SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
            await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

            Image ima = new Image();

            ima.Source = bitmapSource;

            editImage.Source = bitmapSource;
        }
        private void RenderImageInMainPanel(SoftwareBitmap softwareBitmap)
        {
            SoftwareBitmap displayBitmap = softwareBitmap;

            //Image control only accepts BGRA8 encoding and Premultiplied/no alpha channel. This checks and converts
            //the SoftwareBitmap we want to bind.
            if (displayBitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 ||
                displayBitmap.BitmapAlphaMode != BitmapAlphaMode.Premultiplied)
            {
                displayBitmap = SoftwareBitmap.Convert(displayBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
            }

            // get software bitmap souce
            var source = new SoftwareBitmapSource();

            source.SetBitmapAsync(displayBitmap).GetAwaiter();
            // draw the input image
            InputImage.Source = source;
        }
Example #16
0
        public static async Task <SoftwareBitmapSource> LoadReceiptBitmapSource(StorageFile mFile)
        {
            if (mFile != null)
            {
                using (var stream = await mFile.OpenAsync(FileAccessMode.Read))
                {
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);

                    SoftwareBitmap sBitmap = await decoder.GetSoftwareBitmapAsync();

                    SoftwareBitmap       softwareBitmapBGR8 = SoftwareBitmap.Convert(sBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                    SoftwareBitmapSource bitmapSource       = new SoftwareBitmapSource();
                    await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

                    return(bitmapSource);
                }
            }
            return(null);
        }
Example #17
0
        private async void TakeSnapshot(object sender, RoutedEventArgs e)
        {
            var bitmap = FixBitmapForBGRA8(SnapshotVidoEffect.GetSnapShot());
            var source = new SoftwareBitmapSource();
            await source.SetBitmapAsync(bitmap);

            var newSnapshot = new ViewImageEditorMetadata();

            newSnapshot.Bitmap = bitmap;
            newSnapshot.Source = source;
            newSnapshot.Number = snapshots.Count + 1;
            var pos = mePlayer.Position;

            newSnapshot.Position = new TimeSpan(pos.Days, pos.Hours, pos.Minutes, pos.Seconds);;

            snapshots.Add(newSnapshot);

            SendSystemNotification("Snapshot taken!");
        }
Example #18
0
        private async Task <Comment> parseSingleComment(HtmlNode node)
        {
            HtmlNode commentSection = node.SelectSingleNode(".//section");

            Comment resultComment = new Comment();

            if (!isAttributeValueContains(commentSection.Attributes, "class", "comment-bad"))
            {
                SoftwareBitmapSource source = new SoftwareBitmapSource();
                await source.SetBitmapAsync(
                    await webManager.getCachedImageAsync(normalizeImageUriDebug(
                                                             commentSection.SelectSingleNode(".//ul[@class='comment-info']")
                                                             .SelectSingleNode(".//img[@class='comment-avatar']")
                                                             .Attributes["src"].Value)));

                resultComment.id = int.Parse(commentSection.Attributes["data-id"].Value);

                if (isAttributeValueContains(commentSection.Attributes, "class", "comment-new"))
                {
                    resultComment.isRead = false;
                }

                resultComment.text = await htmlParser.convertNodeToParagraph(commentSection.SelectSingleNode(".//div[@class='text']"));

                resultComment.author = commentSection.SelectSingleNode(".//ul[@class='comment-info']")
                                       .SelectSingleNode("./li")
                                       .InnerText
                                       .Trim();

                resultComment.author_image = source;

                resultComment.datetime = commentSection.SelectSingleNode(".//time").InnerText.Replace("\n", String.Empty).Trim();

                resultComment.rating = int.Parse(commentSection.SelectSingleNode(".//span[@class='vote-count']").InnerText);
            }
            else
            {
                resultComment.id   = int.Parse(commentSection.Attributes["data-id"].Value);
                resultComment.text = await htmlParser.convertNodeToParagraph(commentSection.SelectSingleNode(".//div[@class='text']"));
            }

            return(resultComment);
        }
Example #19
0
        /// <summary>
        /// Configure an IFrameSource from a StorageFile or MediaCapture instance to produce optionally a specified format of frame
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        private async Task ConfigureFrameSourceAsync(object source, ISkillFeatureImageDescriptor inputImageDescriptor = null)
        {
            await m_lock.WaitAsync();

            {
                // Reset bitmap rendering component
                UIImageViewer.Source     = null;
                m_renderTargetFrame      = null;
                m_processedBitmapSource  = new SoftwareBitmapSource();
                UIImageViewer.Source     = m_processedBitmapSource;
                m_bodyRenderer.IsVisible = false;

                // Clean up previous frame source
                if (m_frameSource != null)
                {
                    m_frameSource.FrameArrived -= FrameSource_FrameAvailable;
                    var disposableFrameSource = m_frameSource as IDisposable;
                    if (disposableFrameSource != null)
                    {
                        // Lock disposal based on frame source consumers
                        disposableFrameSource.Dispose();
                    }
                }

                // Create new frame source and register a callback if the source fails along the way
                m_frameSource = await FrameSourceFactory.CreateFrameSourceAsync(
                    source,
                    (sender, message) =>
                {
                    NotifyUser(message);
                },
                    inputImageDescriptor);
            }
            m_lock.Release();

            // If we obtained a valid frame source, start it
            if (m_frameSource != null)
            {
                m_frameSource.FrameArrived += FrameSource_FrameAvailable;
                await m_frameSource.StartAsync();
            }
        }
        private async Task ExecuteBrowsePictureCommandAsync()
        {
            try
            {
                FileOpenPicker fileOpenPicker = new FileOpenPicker()
                {
                    SuggestedStartLocation = PickerLocationId.PicturesLibrary, ViewMode = PickerViewMode.Thumbnail
                };
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".jpeg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.FileTypeFilter.Add(".bmp");
                IReadOnlyList <StorageFile> selectedFiles = await fileOpenPicker.PickMultipleFilesAsync();

                if (selectedFiles != null)
                {
                    foreach (var item in selectedFiles)
                    {
                        SoftwareBitmap softwareBitmap;

                        using (IRandomAccessStream stream = await item.OpenAsync(FileAccessMode.Read))
                        {
                            // Create the decoder from the stream
                            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);

                            // Get the SoftwareBitmap representation of the file
                            softwareBitmap = await decoder.GetSoftwareBitmapAsync();

                            softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                            var softwareBitmapSource = new SoftwareBitmapSource();
                            await softwareBitmapSource.SetBitmapAsync(softwareBitmap);

                            Pictures.Add(new BitmapWrapper(softwareBitmap, softwareBitmapSource));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                await new MessageDialog(ex.Message).ShowAsync();
            }
        }
        private async void UpdatePhotoElements()
        {
            BtnPhoto.Content          = "Replace Photo";
            BtnDeletePhoto.Visibility = Visibility.Visible;
            RowPhoto.Height           = new GridLength(1, GridUnitType.Star);
            ProgRing.IsActive         = true;

            SoftwareBitmapSource mSource = await PhotoFunctions.LoadReceiptBitmapSource(capturedPhoto);

            if (mSource != null)
            {
                ImgReceipt.Source = mSource;
            }
            else
            {
                RowPhoto.Height = new GridLength(0);
            }

            ProgRing.IsActive = false;
        }
Example #22
0
        private async Task SetCurrentFile(string file)
        {
            loadingBorder.Visibility = Visibility.Visible;

            var streamTask = provider.OpenEntryAsRandomAccessStreamAsync(file);
            var stream     = await streamTask;

            SoftwareBitmap bitmap = await CreateResizedBitmap(stream, (uint)canvas.RenderSize.Width, (uint)canvas.RenderSize.Height);

            var source        = new SoftwareBitmapSource();
            var setSourceTask = source.SetBitmapAsync(bitmap);

            image.Source          = source;
            imageControl.Filename = ExtractFilename(file);

            await setSourceTask;

            loadingBorder.Visibility = Visibility.Collapsed;
            imageBorder.Visibility   = Visibility.Visible;
        }
Example #23
0
        /// <summary>
        /// Evalutaes the builder.
        /// If invalid, lissts the problems.
        /// If valid, builds a landscape and generates the output (if the layer is present)
        /// </summary>
        public async Task Run()
        {
            const string     nln = "\n";
            LandscapeBuilder landscapeBuilder = BuildLandscapeBuilder();
            await Output.SetAsync(string.Join(nln, landscapeBuilder.GetFullReport()));

            if (landscapeBuilder.IsValid())
            {
                await Output.SetAsync(Output.Value + nln + "===  VALID  ===");

                Landscape landscape = landscapeBuilder.Build();
                try {
                    HeightMapImageOutputter outputter = (HeightMapImageOutputter)landscape.GetOutputter <byte[]>("img");

                    await Output.SetAsync(Output.Value + nln + "Generating the landscape.");

                    byte[] bytes = outputter.GetObject(new Coordinate());
                    await Output.SetAsync(Output.Value + nln + "Generating the image.");

                    await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() => {
                        LatestBitmap = outputter.BytesToBitmap(bytes);
                        if (LatestBitmap.BitmapPixelFormat != BitmapPixelFormat.Bgra8 || LatestBitmap.BitmapAlphaMode == BitmapAlphaMode.Straight)
                        {
                            LatestBitmap = SoftwareBitmap.Convert(LatestBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                        }
                        SoftwareBitmapSource source = new SoftwareBitmapSource();
                        await source.SetBitmapAsync(LatestBitmap);
                        SoftwareBitmapSource.SetFromUIThread(source);
                    }).AsTask();

                    await Output.SetAsync(Output.Value + nln + "Preview is ready,");
                } catch (Exception err) {
                    await Output.SetAsync(Output.Value + nln + "Failed to retrieve the Bitmap Outputter."
                                          + nln + "To enable the preview add a HeightMapImageOutputterBuilder with id of \"img\"" + nln + err.Message);
                }
            }
            else
            {
                await Output.SetAsync(Output.Value + nln + "=== INVALID ===");
            }
        }
Example #24
0
        public async Task <ImageSource> GetImageSourceAsync()
        {
            if (_decoder != null)
            {
                switch (_decoder.BitmapPixelFormat)
                {
                case BitmapPixelFormat.Unknown:
                    break;

                case BitmapPixelFormat.Rgba16:
                    break;

                case BitmapPixelFormat.Rgba8:
                    break;

                case BitmapPixelFormat.Gray16:
                    break;

                case BitmapPixelFormat.Gray8:
                    break;

                case BitmapPixelFormat.Bgra8:
                    break;

                case BitmapPixelFormat.Nv12:
                    break;

                case BitmapPixelFormat.Yuy2:
                    break;

                default:
                    break;
                }

                var bitmap = await _decoder.GetSoftwareBitmapAsync();

                var source = new SoftwareBitmapSource();
                await source.SetBitmapAsync(bitmap);
            }
            return(default(ImageSource));
        }
Example #25
0
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            UIPreviewImage.Source = null;
            ResultText.Visibility = Visibility.Collapsed;
            try
            {
                // Get image using FileOpenPicker
                var fileOpenPicker = new FileOpenPicker();
                fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".jpeg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
                var selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();

                // Change image to SoftwareBitmap to show in AppPage
                SoftwareBitmap softwareBitmap;
                using (var stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
                {
                    var decoder = await BitmapDecoder.CreateAsync(stream);

                    softwareBitmap = await decoder.GetSoftwareBitmapAsync();

                    softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }

                // Show image on AppPage
                var imageSource = new SoftwareBitmapSource();
                await imageSource.SetBitmapAsync(softwareBitmap);

                UIPreviewImage.Source = imageSource;

                // Change image from SoftwareBitmap to VideoFrame
                var inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);

                await EvaluateVideoFrameAsync(inputImage);
            }
            catch (Exception ex)
            {
            }
        }
        private async void DisplayImage(byte[] img)
        {
            /*
             * var jpgImage = new Byte[img.Count * PACKET_SIZE];
             * for (int i = 0; i < img.Count; ++i)
             * {
             *  for (int j = 0; j < img[i].Length; ++j)
             *  {
             *      jpgImage[(i * PACKET_SIZE) + j] = img[i][j];
             *  }
             * }
             */

            try
            {
                BitmapDecoder decoder = await BitmapDecoder.CreateAsync(ConvertTo(img));

                SoftwareBitmap sftwareBmp = await decoder.GetSoftwareBitmapAsync();

                SoftwareBitmap displayableImage = SoftwareBitmap.Convert(sftwareBmp, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);


                // var data = await decoder.GetPixelDataAsync();
                // var bytes = data.DetachPixelData();

                await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
                                                                                                            async() =>
                {
                    var source = new SoftwareBitmapSource();
                    await source.SetBitmapAsync(displayableImage);
                    testImg.Source = source;
                }
                                                                                                            );

                Debug.WriteLine("Displayed!");
            } catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            serverDatagramSocket.MessageReceived += ServerDatagramSocket_MessageReceived;
        }
        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            photo = (StorageFile)e.Parameter;

            Frame rootFrame = Window.Current.Content as Frame;

            MyProgressRing.IsActive   = true;
            MyProgressRing.Visibility = Visibility.Visible;
            PageContent.Visibility    = Visibility.Collapsed;

            IRandomAccessStream accessStream = await photo.OpenAsync(FileAccessMode.Read);

            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(accessStream);

            SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();

            SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap,
                                                                       BitmapPixelFormat.Bgra8,
                                                                       BitmapAlphaMode.Premultiplied);

            SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
            await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

            Picture.Source = bitmapSource;

            var stream = await photo.OpenStreamForReadAsync();

            var result = await AnalyzeImage(stream);

            this.DataContext = (result.Any()) ? result.First().Scores : null;
            if (DataContext == null)
            {
                await new Windows.UI.Popups.MessageDialog("No pude detectar ninguna cara :(").ShowAsync();
                rootFrame.GoBack();
            }

            MyProgressRing.IsActive   = false;
            MyProgressRing.Visibility = Visibility.Collapsed;
            PageContent.Visibility    = Visibility.Visible;
        }
Example #28
0
        /// <summary>
        /// Gets the current preview frame as a SoftwareBitmap, displays its properties in a TextBlock, and can optionally display the image
        /// in the UI and/or save it to disk as a jpg
        /// </summary>
        /// <returns></returns>
        private async Task GetPreviewFrameAsSoftwareBitmapAsync()
        {
            // Get information about the preview
            var previewProperties = _mediaCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview) as VideoEncodingProperties;

            // Create the video frame to request a SoftwareBitmap preview frame
            var videoFrame = new VideoFrame(BitmapPixelFormat.Bgra8, (int)previewProperties.Width, (int)previewProperties.Height);

            // Capture the preview frame
            using (var currentFrame = await _mediaCapture.GetPreviewFrameAsync(videoFrame))
            {
                // Collect the resulting frame
                SoftwareBitmap previewFrame = currentFrame.SoftwareBitmap;

                // Show the frame information
                FrameInfoTextBlock.Text = String.Format("{0}x{1} {2}", previewFrame.PixelWidth, previewFrame.PixelHeight, previewFrame.BitmapPixelFormat);

                // Add a simple green filter effect to the SoftwareBitmap
                if (GreenEffectCheckBox.IsChecked == true)
                {
                    ApplyGreenFilter(previewFrame);
                }

                // Show the frame (as is, no rotation is being applied)
                if (ShowFrameCheckBox.IsChecked == true)
                {
                    // Create a SoftwareBitmapSource to display the SoftwareBitmap to the user
                    var sbSource = new SoftwareBitmapSource();
                    await sbSource.SetBitmapAsync(previewFrame);

                    // Display it in the Image control
                    PreviewFrameImage.Source = sbSource;
                }

                // Save the frame (as is, no rotation is being applied)
                if (SaveFrameCheckBox.IsChecked == true)
                {
                    await SaveSoftwareBitmapAsync(previewFrame);
                }
            }
        }
Example #29
0
        private async void addImageToGrid()
        {
            _images.getImages().ForEach(async image =>
            {
                var backupImage = image;
                if (backupImage.BitmapPixelFormat != BitmapPixelFormat.Bgra8 ||
                    backupImage.BitmapAlphaMode == BitmapAlphaMode.Straight)
                {
                    backupImage = SoftwareBitmap.Convert(backupImage, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }

                Image imageChild = new Image();
                var sbs          = new SoftwareBitmapSource();
                await sbs.SetBitmapAsync(backupImage);

                imageChild.Source   = sbs;
                imageChild.Margin   = new Thickness(20);
                imageChild.MaxWidth = 300;
                ImageGrid.Children.Add(imageChild);
            });
        }
Example #30
0
        public NewItemPreview(StorageFile file, bool isVideo = false)
        {
            InitializeComponent();
            var tmpFile = file;

            Task.Factory.StartNew(async() =>
            {
                if (!isVideo)
                {
                    using (IRandomAccessStream stream = await tmpFile.OpenAsync(FileAccessMode.Read))
                    {
                        BitmapDecoder decoder             = await BitmapDecoder.CreateAsync(stream);
                        SoftwareBitmap softwareBitmap     = await decoder.GetSoftwareBitmapAsync();
                        SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                        SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
                        await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);
                        ImagePreview.Source = bitmapSource;
                    }
                }
            }, CancellationToken.None, TaskCreationOptions.None, DiskService.Client.Sync);
        }
Example #31
0
        private async void BrowsePhotoButton_Click(object sender, RoutedEventArgs e)
        {
            FileOpenPicker openPicker = new FileOpenPicker();

            openPicker.ViewMode = PickerViewMode.Thumbnail;
            openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
            openPicker.FileTypeFilter.Add(".jpg");
            openPicker.FileTypeFilter.Add(".jpeg");
            openPicker.FileTypeFilter.Add(".png");

            StorageFile file = await openPicker.PickSingleFileAsync();

            if (file != null)
            {
                photoStream = await camera.ConvertToStream(file);

                photoBitmap = await camera.ConvertToSoftwareBitmap(photoStream);

                photoBitmapSource = await camera.ConvertToSoftwareBitmapSource(photoBitmap);
            }
        }
Example #32
0
        private async void ImageLoaded(object sender, RoutedEventArgs r)
        {
            using (var stream = await item.path.OpenAsync(FileAccessMode.Read))
            {
                var bitmapDecoder = await BitmapDecoder.CreateAsync(stream);

                var pixelProvider = await bitmapDecoder.GetPixelDataAsync();

                bits = pixelProvider.DetachPixelData();
                var softwareBitmap = new SoftwareBitmap(
                    BitmapPixelFormat.Bgra8,
                    (int)bitmapDecoder.PixelWidth,
                    (int)bitmapDecoder.PixelHeight,
                    BitmapAlphaMode.Premultiplied);
                softwareBitmap.CopyFromBuffer(bits.AsBuffer());
                var softwareBitmapSource = new SoftwareBitmapSource();
                await softwareBitmapSource.SetBitmapAsync(softwareBitmap);

                img.Source = softwareBitmapSource;
            }
        }
Example #33
0
        // </SnippetRegisterMetadataHandlerForImageSubtitles>

        // <SnippetImageSubtitleCueEntered>
        private async void metadata_ImageSubtitleCueEntered(TimedMetadataTrack timedMetadataTrack, MediaCueEventArgs args)
        {
            // Check in case there are different tracks and the handler was used for more tracks
            if (timedMetadataTrack.TimedMetadataKind == TimedMetadataKind.ImageSubtitle)
            {
                var cue = args.Cue as ImageCue;
                if (cue != null)
                {
                    await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
                    {
                        var source = new SoftwareBitmapSource();
                        await source.SetBitmapAsync(cue.SoftwareBitmap);
                        SubtitleImage.Source = source;
                        SubtitleImage.Width  = cue.Extent.Width;
                        SubtitleImage.Height = cue.Extent.Height;
                        SubtitleImage.SetValue(Canvas.LeftProperty, cue.Position.X);
                        SubtitleImage.SetValue(Canvas.TopProperty, cue.Position.Y);
                    });
                }
            }
        }
        /// <summary>
        /// Gets the current preview frame as a SoftwareBitmap, displays its properties in a TextBlock, and can optionally display the image
        /// in the UI and/or save it to disk as a jpg
        /// </summary>
        /// <returns></returns>
        private async Task GetPreviewFrameAsSoftwareBitmapAsync()
        {
            // Get information about the preview
            var previewProperties = _mediaCapture.VideoDeviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview) as VideoEncodingProperties;

            // Create the video frame to request a SoftwareBitmap preview frame
            var videoFrame = new VideoFrame(BitmapPixelFormat.Bgra8, (int)previewProperties.Width, (int)previewProperties.Height);

            // Capture the preview frame
            using (var currentFrame = await _mediaCapture.GetPreviewFrameAsync(videoFrame))
            {
                // Collect the resulting frame
                SoftwareBitmap previewFrame = currentFrame.SoftwareBitmap;

                // Show the frame information
                FrameInfoTextBlock.Text = String.Format("{0}x{1} {2}", previewFrame.PixelWidth, previewFrame.PixelHeight, previewFrame.BitmapPixelFormat);

                // Add a simple green filter effect to the SoftwareBitmap
                if (GreenEffectCheckBox.IsChecked == true)
                {
                    ApplyGreenFilter(previewFrame);
                }

                // Show the frame (as is, no rotation is being applied)
                if (ShowFrameCheckBox.IsChecked == true)
                {
                    // Create a SoftwareBitmapSource to display the SoftwareBitmap to the user
                    var sbSource = new SoftwareBitmapSource();
                    await sbSource.SetBitmapAsync(previewFrame);

                    // Display it in the Image control
                    PreviewFrameImage.Source = sbSource;
                }

                // Save the frame (as is, no rotation is being applied)
                if (SaveFrameCheckBox.IsChecked == true)
                {
                    await SaveSoftwareBitmapAsync(previewFrame);
                }
            }
        }
Example #35
0
        private static async Task<ImageModel> Capture()
        {
            var allVideoDevices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);

            // Get the desired camera by panel
            DeviceInformation desiredDevice = allVideoDevices.FirstOrDefault(x => x.EnclosureLocation != null && x.EnclosureLocation.Panel == Windows.Devices.Enumeration.Panel.Back);
            if (desiredDevice ==  null)
            {
                Debug.Write("no Camrea");
                return null;
            }
            CameraCaptureUI cameraUI = new CameraCaptureUI();
            cameraUI.PhotoSettings.Format = CameraCaptureUIPhotoFormat.Jpeg;
            cameraUI.PhotoSettings.AllowCropping = false;
            //cameraUI.PhotoSettings.CroppedSizeInPixels = new Size(1280,720);

            StorageFile photo = await cameraUI.CaptureFileAsync(CameraCaptureUIMode.Photo);
            if (photo == null)
                return null;

            IRandomAccessStream stream = await photo.OpenAsync(FileAccessMode.Read);
            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
            decoder = await BitmapDecoder.CreateAsync( await decoder.GetThumbnailAsync());

            SoftwareBitmap bitmapBgr8 = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

            SoftwareBitmapSource imgsource = new SoftwareBitmapSource();
            await imgsource.SetBitmapAsync(bitmapBgr8);
            ImageModel imgModel = new ImageModel() { ImgFile = photo, ThumbnailImage = imgsource };
            
            return imgModel;
        }
Example #36
0
        private async Task<SoftwareBitmapSource> PreparePhoto(StorageFile photo)
        {
            IRandomAccessStream stream = await photo.OpenAsync(FileAccessMode.Read);
            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
            SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();

            SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
            SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
            await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

            return bitmapSource;
        }
        private async void file2SoftwareBitmapSource(StorageFile file, int index = 0, bool isAddImage = false)
        {
            if (!isAddImage)
            {
                IStorageFolder applicationFolder = ApplicationData.Current.TemporaryFolder;
                await file.CopyAndReplaceAsync(await applicationFolder.CreateFileAsync(file.Name, CreationCollisionOption.ReplaceExisting));
            }

            SoftwareBitmapSource source = new SoftwareBitmapSource();
            SoftwareBitmap sb = null;
            using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
            {
                BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
                SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                sb = softwareBitmap;
            }
            await source.SetBitmapAsync(sb);
            imageList.Insert(index, new CommunityImageList { imgUri = source, imgName = file.Name, imgPath = file.Path, imgAppPath = "ms-appdata:///Temp/" + file.Name });
        }
Example #38
0
        private async void mostrarFoto(StorageFile file)
        {
            IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read);
            BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
            SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
            SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

            SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
            await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

            Image ima = new Image();
            ima.Source = bitmapSource;

            editImage.Source = bitmapSource;
        }
 //callback funkcija kad se uslika 
 public void SlikanjeGotovo(SoftwareBitmapSource slikica)
 {
     Slika = slikica;
 }
Example #40
0
 private async void CameraButton_Click(object sender, RoutedEventArgs e)
 {
     photoStream = await camera.TakePhoto(CameraCaptureUIPhotoFormat.Jpeg);
     photoBitmap = await camera.ConvertToSoftwareBitmap(photoStream);
     photoBitmapSource = await camera.ConvertToSoftwareBitmapSource(photoBitmap);
 }
        async Task InitSize()
        {
            try
            {
//                this._file = await StorageHelper.TryGetFileFromPathAsync(path);

                if (this._file == null) return;

                var appView = ApplicationView.GetForCurrentView();

                //this.gifViewer.Visibility = Visibility.Collapsed;
                this.Img.Visibility = Visibility.Visible;

                IInputStream inputStream = await this._file.OpenReadAsync();
                IRandomAccessStream memStream = new InMemoryRandomAccessStream();
                await RandomAccessStream.CopyAsync(inputStream, memStream);
                BitmapDecoder decoder = await BitmapDecoder.CreateAsync(memStream);
                SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);

                if (softwareBitmap == null)
                    return;
                SoftwareBitmapSource source = new SoftwareBitmapSource();
                await source.SetBitmapAsync(softwareBitmap);

                if (softwareBitmap.PixelHeight > appView.VisibleBounds.Height || softwareBitmap.PixelWidth > appView.VisibleBounds.Width)
                {
                    double ratio1, ratio2;
                    ratio1 = (double)softwareBitmap.PixelWidth / (double)appView.VisibleBounds.Width;
                    ratio2 = (double)softwareBitmap.PixelHeight / (double)appView.VisibleBounds.Height;

                    if (ratio1 > ratio2)
                    {
                        this.Img.Width = appView.VisibleBounds.Width;
                        this.Img.Height = softwareBitmap.PixelHeight / ratio1;
                        if (ratio1 > 1.0)
                            this.sv.MaxZoomFactor *= (float)ratio1;
                    }
                    else
                    {
                        this.Img.Width = softwareBitmap.PixelWidth / ratio2;
                        this.Img.Height = appView.VisibleBounds.Height;
                        if (ratio2 > 1.0)
                            this.sv.MaxZoomFactor *= (float)ratio2;
                    }
                }
                else
                {
                    this.Img.Width = softwareBitmap.PixelWidth;
                    this.Img.Height = softwareBitmap.PixelHeight;
                }

                this.sv.Width = appView.VisibleBounds.Width;
                this.sv.Height = appView.VisibleBounds.Height;
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
        }
Example #42
0
        private void LoadIDButton_Click(object sender, RoutedEventArgs e)
        {
            idStream = photoStream;
            idBitmap = photoBitmap;
            idBitmapSource = photoBitmapSource;

            IDPhoto.Source = idBitmapSource;
        }
Example #43
0
        private static async Task<SoftwareBitmapSource> CropPhoto(StorageFile photo, FaceRectangle rectangle)
        {
            using (var imageStream = await photo.OpenReadAsync())
            {
                var decoder = await BitmapDecoder.CreateAsync(imageStream);
                if (decoder.PixelWidth >= rectangle.Left + rectangle.Width || decoder.PixelHeight >= rectangle.Top + rectangle.Height)
                {
                    var transform = new BitmapTransform
                    {
                        Bounds = new BitmapBounds
                        {
                            X = (uint)rectangle.Left,
                            Y = (uint)rectangle.Top,
                            Height = (uint)rectangle.Height,
                            Width = (uint)rectangle.Width
                        }
                    };

                    var softwareBitmapBGR8 = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied, transform, ExifOrientationMode.IgnoreExifOrientation, ColorManagementMode.DoNotColorManage);
                    SoftwareBitmapSource bitmapSource = new SoftwareBitmapSource();
                    await bitmapSource.SetBitmapAsync(softwareBitmapBGR8);

                    return bitmapSource;
                }
                return null;
            }
        }
 //TODO:未登录时不能选择上传头像
 private async void headimgRectangle_Tapped(object sender, TappedRoutedEventArgs e)
 {
     //if (appSetting.Values.ContainsKey("idNum"))
     try
     {
         var vault = new Windows.Security.Credentials.PasswordVault();
         var credentialList = vault.FindAllByResource(resourceName);
         credentialList[0].RetrievePassword();
         if (credentialList.Count > 0)
         {
             FileOpenPicker openPicker = new FileOpenPicker();
             openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
             openPicker.FileTypeFilter.Add(".png");
             openPicker.FileTypeFilter.Add(".jpg");
             openPicker.FileTypeFilter.Add(".bmp");
             openPicker.FileTypeFilter.Add(".gif");
             openPicker.ContinuationData["Operation"] = "img";
             StorageFile file = await openPicker.PickSingleFileAsync();
             if (file != null)
             {
                 ClipHeadGrid.Visibility = Visibility.Visible;
                 BackOpacityGrid.Visibility = Visibility.Visible;
                 SoftwareBitmap sb = null;
                 using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.Read))
                 {
                     // Create the decoder from the stream
                     BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
                     // Get the SoftwareBitmap representation of the file
                     SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                     sb = softwareBitmap;
                     // return softwareBitmap;
                 }
                 SoftwareBitmapSource source = new SoftwareBitmapSource();
                 await source.SetBitmapAsync(sb);
                 headImage.Source = source;
             }
         }
         else
         {
             var msgPopup = new Data.loginControl("您还没有登录 不能上传头像哦~");
             msgPopup.LeftClick += (s, c) => { Frame rootFrame = Window.Current.Content as Frame; rootFrame.Navigate(typeof(LoginPage)); };
             msgPopup.RightClick += (s, c) => { new MessageDialog("您可以先去社区逛一逛~"); };
             msgPopup.ShowWIndow();
         }
     }
     catch
     {
         var msgPopup = new Data.loginControl("您还没有登录 不能上传头像哦~");
         msgPopup.LeftClick += (s, c) => { Frame rootFrame = Window.Current.Content as Frame; rootFrame.Navigate(typeof(LoginPage)); };
         msgPopup.RightClick += (s, c) => { new MessageDialog("您可以先去社区逛一逛~"); };
         msgPopup.ShowWIndow();
     }
 }
        public static async Task<SoftwareBitmapSource> ImagePathToSoftwareBitmapSource(string path)
        {
            var file = await StorageHelper.TryGetFileAsync(path);
            var bitmap = await StorageFileToSoftwareBitmap(file);

            if (bitmap == null) return null;

            var source = new SoftwareBitmapSource();
            await source.SetBitmapAsync(bitmap);

            return source;
        }
Example #46
0
        private async void InitializeCameraAsync()
        {
            sbSource = new SoftwareBitmapSource();
            receviebitMap = new SoftwareBitmap(BitmapPixelFormat.Bgra8, 240, 180, 0);

            buffer = new Windows.Storage.Streams.Buffer((uint)(240 * 180 * 8));

            /*  stream client  close this */
            imageElement1.Source = sbSource;

            streamSocketSrv = new StreamSocketListenerServer();
            await streamSocketSrv.start(serverip, "22343");
          
            streamSocketClient = new StreamSocketClient();

            textBox.Text = clientip;
        }
Example #47
0
        private async void LoadPortraitButton_Click(object sender, RoutedEventArgs e)
        {
            portraitStream = photoStream;
            portraitBitmap = photoBitmap;
            portraitBitmapSource = photoBitmapSource;

            PortraitPhoto.Source = portraitBitmapSource;

            portraitPath = await StorageAPI.SavePhoto(portraitStream, "Portrait");
        }
Example #48
0
 public async Task TakePhotoAsync(Action<SoftwareBitmapSource> callback)
 {
     //kada uslika postaviti svoj stream 
     Slika = new InMemoryRandomAccessStream();
     try
     {
         //konvertovati uslikano u Software bitmap da se moze prikazati u image kontroli
         await MediaCapture.CapturePhotoToStreamAsync(ImageEncodingProperties.CreateBmp(), Slika);
         BitmapDecoder decoder = await BitmapDecoder.CreateAsync(Slika);
         SoftwareBitmap softwareBitmap = await decoder.GetSoftwareBitmapAsync();
         SoftwareBitmap softwareBitmapBGR8 = SoftwareBitmap.Convert(softwareBitmap,
 BitmapPixelFormat.Bgra8,
 BitmapAlphaMode.Premultiplied);
          SlikaBitmap = new SoftwareBitmapSource();
         await SlikaBitmap.SetBitmapAsync(softwareBitmapBGR8);
         callback(SlikaBitmap);
     }
     catch (Exception ex)
     {
         Debug.WriteLine("Exception when taking a photo: {0}", ex.ToString());
     }
 }
Example #49
0
        private async Task<OcrResultDisplay> ProcessImage(StorageFile file)
        {
            SoftwareBitmap bitmap;
            ImageSource source;
            using (var imgStream = await file.OpenAsync(FileAccessMode.Read))
            {
                var decoder = await BitmapDecoder.CreateAsync(imgStream);
                bitmap = await decoder.GetSoftwareBitmapAsync();
            }

            if (bitmap == null)
            {
                source = new BitmapImage();
                return new OcrResultDisplay
                {
                    OcrString = "No text found.\n",
                    OcrImage = source
                };
            }

            OcrEngine engine = OcrEngine.TryCreateFromLanguage(new Windows.Globalization.Language("en"));
            OcrResult result = await engine.RecognizeAsync(bitmap);
            StringBuilder sb = new StringBuilder();
            if (result.Lines == null)
            {
                source = new SoftwareBitmapSource();
                bitmap = SoftwareBitmap.Convert(bitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                await ((SoftwareBitmapSource)source).SetBitmapAsync(bitmap);
                return new OcrResultDisplay
                {
                    OcrString = "No text found.\n",
                    OcrImage = source
                };
            }
            foreach (var line in result.Lines)
            {
                foreach (var word in line.Words)
                {
                    sb.Append(word.Text + " ");
                }
                sb.AppendLine();
            }

            source = new SoftwareBitmapSource();
            bitmap = SoftwareBitmap.Convert(bitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
            await ((SoftwareBitmapSource)source).SetBitmapAsync(bitmap);
            return new OcrResultDisplay { OcrString = sb.ToString(), OcrImage = source };
        }