/// <summary>
 /// Helper method to display the device orientation in the specified text box.
 /// </summary>
 /// <param name="tb">
 /// The text box receiving the orientation value.
 /// </param>
 /// <param name="orientation">
 /// The orientation value.
 /// </param>
 private void DisplayOrientation(TextBlock tb, SimpleOrientation orientation)
 {
     switch (orientation)
     {
         case SimpleOrientation.NotRotated:
             tb.Text = "Not Rotated";
             break;
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             tb.Text = "Rotated 90 Degrees Counterclockwise";
             break;
         case SimpleOrientation.Rotated180DegreesCounterclockwise:
             tb.Text = "Rotated 180 Degrees Counterclockwise";
             break;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             tb.Text = "Rotated 270 Degrees Counterclockwise";
             break;
         case SimpleOrientation.Faceup:
             tb.Text = "Faceup";
             break;
         case SimpleOrientation.Facedown:
             tb.Text = "Facedown";
             break;
         default:
             tb.Text = "Unknown orientation";
             break;
     }
 }

 private void ShowOrientationText(SimpleOrientation simpleOrientation)
 {
     switch (simpleOrientation)
     {
         case SimpleOrientation.NotRotated:
             AlertBox.Text = "Not Rotated";
             break;
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             AlertBox.Text = "90 Degrees CounterClockwise";
             break;
         case SimpleOrientation.Rotated180DegreesCounterclockwise:
             AlertBox.Text = "180 Degrees Rotated";
             break;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             AlertBox.Text = "270 Degrees Rotated CounterClockwise";
             break;
         case SimpleOrientation.Facedown:
             AlertBox.Text = "Face Down";
             break;
         case SimpleOrientation.Faceup:
             AlertBox.Text = "Face Up";
             break;
         default:
             AlertBox.Text = "Unknown";
             break;
     }
 }

 private VideoRotation GetVideoRotation(SimpleOrientation orientation)
 {
     switch (orientation)
     {
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             return VideoRotation.Clockwise270Degrees;
         case SimpleOrientation.Rotated180DegreesCounterclockwise:
             return VideoRotation.Clockwise180Degrees;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             return VideoRotation.Clockwise90Degrees;
         default:
             return VideoRotation.None;
     }
 }

 private static VideoRotation ConvertSimpleOrientationToVideoRotation(SimpleOrientation orientation)
 {
     switch (orientation)
     {
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             return VideoRotation.Clockwise270Degrees;
         case SimpleOrientation.Rotated180DegreesCounterclockwise:
             return VideoRotation.Clockwise180Degrees;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             return VideoRotation.Clockwise90Degrees;
         case SimpleOrientation.NotRotated:
         default:
             return VideoRotation.None;
     }
 }

 private static SimpleOrientation SubtractOrientations(SimpleOrientation a, SimpleOrientation b)
 {
     var aRot = ConvertSimpleOrientationToClockwiseDegrees(a);
     var bRot = ConvertSimpleOrientationToClockwiseDegrees(b);
     // Add 360 to ensure the modulus operator does not operate on a negative
     var result = (360 + (aRot - bRot)) % 360;
     return ConvertClockwiseDegreesToSimpleOrientation(result);
 }

        /// <summary>
        /// Event handler for orientation sensor changes.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void OrientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args)
        {
            if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown)
            {
                _deviceOrientation = args.Orientation;
            }

            // Update the UI button orientation
            UpdateButtonOrientation();
        }

 /// <summary>
 /// Converts the given orientation of the device in space to the corresponding rotation in degrees
 /// </summary>
 /// <param name="orientation">The orientation of the device in space</param>
 /// <returns>An orientation in degrees</returns>
 private static int ConvertDeviceOrientationToDegrees(SimpleOrientation orientation)
 {
     switch (orientation)
     {
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             return 90;
         case SimpleOrientation.Rotated180DegreesCounterclockwise:
             return 180;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             return 270;
         case SimpleOrientation.NotRotated:
         default:
             return 0;
     }
 }

        /// <summary>
        /// Occurs each time the simple orientation sensor reports a new sensor reading.
        /// </summary>
        /// <param name="sender">The event source.</param>
        /// <param name="args">The event data.</param>
        private async void OrientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args)
        {
            if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown)
            {
                // Only update the current orientation if the device is not parallel to the ground. This allows users to take pictures of documents (FaceUp)
                // or the ceiling (FaceDown) in portrait or landscape, by first holding the device in the desired orientation, and then pointing the camera
                // either up or down, at the desired subject.
                //Note: This assumes that the camera is either facing the same way as the screen, or the opposite way. For devices with cameras mounted
                //      on other panels, this logic should be adjusted.
                _deviceOrientation = args.Orientation;

                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => UpdateButtonOrientation());
            }
        }

 private void OrientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args)
 {
     if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown)
     {
         _deviceOrientation = args.Orientation;
     }
 }

 private void OrientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args)
 {
     if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown)
     {
         // Only update the current orientation if the device is not parallel to the ground. This allows users to take pictures of documents (FaceUp)    
         deviceOrientation = args.Orientation;
     }
 }

 void OnOrientationSensorOrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args)
 {
     // Only update orientatino if the device is not parallel to the ground
     if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown)
     {
         deviceOrientation = args.Orientation;
     }
 }

        private object ConvertOrientationToPhotoOrientation(SimpleOrientation orientation)
        {
            //     if (_mirroringPreview == true)
            //      {
            switch (orientation)
            {
                case SimpleOrientation.Rotated90DegreesCounterclockwise:
                    return PhotoOrientation.Rotate90;
                case SimpleOrientation.Rotated180DegreesCounterclockwise:
                    return PhotoOrientation.Rotate180;
                case SimpleOrientation.Rotated270DegreesCounterclockwise:
                    return PhotoOrientation.Rotate270;
                case SimpleOrientation.NotRotated:
                default:
                    return PhotoOrientation.Normal;
            }
            //        }
            //else
            //{
            //    switch (orientation)
            //    {
            //        case SimpleOrientation.Rotated90DegreesCounterclockwise:
            //            return PhotoOrientation.Rotate90;
            //        case SimpleOrientation.Rotated180DegreesCounterclockwise:
            //            return PhotoOrientation.Rotate180;
            //        case SimpleOrientation.Rotated270DegreesCounterclockwise:
            //            return PhotoOrientation.Rotate270;
            //        case SimpleOrientation.NotRotated:
            //        default:
            //            return PhotoOrientation.Normal;
            //    }
            //}

        }

 private static SimpleOrientation MirrorOrientation(SimpleOrientation orientation)
 {
     // This only affects the 90 and 270 degree cases, because rotating 0 and 180 degrees is the same clockwise and counter-clockwise
     switch (orientation)
     {
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             return SimpleOrientation.Rotated270DegreesCounterclockwise;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             return SimpleOrientation.Rotated90DegreesCounterclockwise;
     }
     return orientation;
 }

 private static SimpleOrientation AddOrientations(SimpleOrientation a, SimpleOrientation b)
 {
     var aRot = ConvertSimpleOrientationToClockwiseDegrees(a);
     var bRot = ConvertSimpleOrientationToClockwiseDegrees(b);
     var result = (aRot + bRot) % 360;
     return ConvertClockwiseDegreesToSimpleOrientation(result);
 }

 /// <summary>
 /// Converts the given orientation of the device in space to the metadata that can be added to captured photos
 /// </summary>
 /// <param name="orientation">The orientation of the device in space</param>
 /// <returns></returns>
 private static PhotoOrientation ConvertOrientationToPhotoOrientation(SimpleOrientation orientation)
 {
     switch (orientation)
     {
         case SimpleOrientation.Rotated90DegreesCounterclockwise:
             return PhotoOrientation.Rotate90;
         case SimpleOrientation.Rotated180DegreesCounterclockwise:
             return PhotoOrientation.Rotate180;
         case SimpleOrientation.Rotated270DegreesCounterclockwise:
             return PhotoOrientation.Rotate270;
         case SimpleOrientation.NotRotated:
         default:
             return PhotoOrientation.Normal;
     }
 }

 protected override async void OnNavigatedTo(NavigationEventArgs e)
 {
     if (orientationSensor != null)
     {
         deviceOrientation = orientationSensor.GetCurrentOrientation();
     }
     await InitializeCameraAsync();
     RegisterEventHandlers();
 }

        private async void ajustes()
        {
            var qualifiers = Windows.ApplicationModel.Resources.Core.ResourceContext.GetForCurrentView().QualifierValues;
            deviceFamily = qualifiers["DeviceFamily"];

            double Width = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().VisibleBounds.Width;
            double Height = Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().VisibleBounds.Height;

            _displayOrientation = _displayInformation.CurrentOrientation;
            if (_orientationSensor != null)
            {
                _deviceOrientation = _orientationSensor.GetCurrentOrientation();
            }

            if (deviceFamily == "Mobile")
            {
                //Content.Visibility = Visibility.Collapsed;

                MainGrid.ColumnDefinitions[0].Width = new GridLength(1577 + 723);
                MainGrid.ColumnDefinitions[1].Width = new GridLength(0);
                MainGrid.RowDefinitions[0].Height = new GridLength(1106);
                MainGrid.RowDefinitions[1].Height = new GridLength(2990);

                Page.SetValue(Grid.ColumnProperty, 0);
                Page.SetValue(Grid.RowProperty, 1);
                Page.Margin = new Thickness(Width * 0.026);

                age_genre.FontSize = 80;
                age_genre.Foreground = new SolidColorBrush(Colors.White);
            }
            else
            {
                //MainGrid.ColumnDefinitions[0].Width = new GridLength(Width * 0.27);
                //MainGrid.ColumnDefinitions[1].Width = new GridLength(Width * 0.72);
                //MainGrid.RowDefinitions[0].Height = new GridLength(Height * 0.27);
                //MainGrid.RowDefinitions[1].Height = new GridLength(Height * 0.72);

                //GridLength minWidth = new GridLength(300);
                //GridLength mg = MainGrid.ColumnDefinitions[0].Width;

                //if (mg.Value < minWidth.Value)
                //{
                //    MainGrid.ColumnDefinitions[0].Width = minWidth;
                //    HoldCamera.Margin = new Thickness(300 * 0.026);
                //    LeftPanel.Margin = new Thickness(300 * 0.026);
                //}

                //HoldCamera.Margin = new Thickness(Width * 0.026);
                //LeftPanel.Margin = new Thickness(Width * 0.026);
                //ProductImage.Margin = new Thickness(Width * 0.026);
                //Content.Margin = new Thickness(Width * 0.026);
                //ProductName.Margin = new Thickness(Width * 0.015625, Height * 0.027777, Width * 0.15625, Height * 0.925925);
                //Price.Margin = new Thickness(Width * 0.3125, Height * 0.027777, Width * 0.015625, Height * 0.185185);
                //logoStore.Margin = new Thickness(Width * 0.3125, Height * 0.185185, Width * 0.015625, Height * 0.027777);
            }

            RegisterEventHandlers();
            await InitContiniousRecognition();
        }

        private void RegisterOrientationEventHandlers()
        {
            if (_orientationSensor != null)
            {
                _orientationSensor.OrientationChanged += OrientationSensor_OrientationChanged;
                _deviceOrientation = _orientationSensor.GetCurrentOrientation();
            }

            _displayInformation.OrientationChanged += DisplayInformation_OrientationChanged;
            _displayOrientation = _displayInformation.CurrentOrientation;
        }

        private async void Application_Resuming(object sender, object o)
        {
            if (orientationSensor != null)
            {
                deviceOrientation = orientationSensor.GetCurrentOrientation();
            }

            if (Frame.CurrentSourcePageType == typeof(CameraView))
            {
                await InitializeCameraAsync();
            }

            RegisterEventHandlers();
        }

        /// <summary>
        /// Attempts to lock the page orientation, hide the StatusBar (on Phone) and registers event handlers for hardware buttons and orientation sensors
        /// </summary>
        /// <returns></returns>
        private async Task SetupUiAsync()
        {
            // Attempt to lock page to landscape orientation to prevent the CaptureElement from rotating, as this gives a better experience
            DisplayInformation.AutoRotationPreferences = DisplayOrientations.Landscape;

            // Hide the status bar
            if (ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar"))
            {
                await Windows.UI.ViewManagement.StatusBar.GetForCurrentView().HideAsync();
            }

            // Populate orientation variables with the current state
            _displayOrientation = _displayInformation.CurrentOrientation;
            if (_orientationSensor != null)
            {
                _deviceOrientation = _orientationSensor.GetCurrentOrientation();
            }
            
            RegisterEventHandlers();

            var picturesLibrary = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures);
            // Fall back to the local app storage if the Pictures Library is not available
            _captureFolder = picturesLibrary.SaveFolder ?? ApplicationData.Current.LocalFolder;
        }