protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            _dataTransferManager = DataTransferManager.GetForCurrentView();
            _dataTransferManager.DataRequested += OnDataRequested;

            _navigationHelper.OnNavigatedTo(e);

            if (InstagramModel != null)
            {
                await InstagramModel.LoadItemsAsync();
                InstagramModel.SelectItem(e.Parameter);

                InstagramModel.ViewType = ViewTypes.Detail;
            }
            DataContext = this;

            // Allow this page to rotate
            _currentOrientations = DisplayInformation.AutoRotationPreferences;
            DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait
                                                        | DisplayOrientations.Landscape
                                                        | DisplayOrientations.LandscapeFlipped
                                                        | DisplayOrientations.PortraitFlipped;

            // Handle orientation changes
            DisplayInformation.GetForCurrentView().OrientationChanged += this.OnOrientationChanged;
            this.TransitionStoryboardState();
        }

 public CameraCaptureUIPage()
 {
   previous = DisplayInformation.AutoRotationPreferences;
   DisplayInformation.AutoRotationPreferences = DisplayOrientations.Landscape;
     this.Loaded += CameraCaptureUIPage_Loaded;
     this.Unloaded += CameraCaptureUIPage_Unloaded;
     this.InitializeComponent();
 }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            this.currentDisplayOrientations = DisplayInformation.AutoRotationPreferences;
            DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait;
            string id = e.Parameter as string;
            this.OpenScript(id);

            base.OnNavigatedTo(e);
        }

 private static int ConvertDisplayOrientationToDegrees(DisplayOrientations orientation)
 {
     switch (orientation)
     {
         case DisplayOrientations.Portrait:
             return 90;
         case DisplayOrientations.LandscapeFlipped:
             return 180;
         case DisplayOrientations.PortraitFlipped:
             return 270;
         case DisplayOrientations.Landscape:
         default:
             return 0;
     }
 }

        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.
        /// This parameter is typically used to configure the page.</param>
        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            _autoRotation = DisplayInformation.AutoRotationPreferences;
            DisplayInformation.AutoRotationPreferences = DisplayOrientations.Landscape;
            // TODO: Prepare page for display here.
            await InitializeAsync();

            // TODO: If your application contains multiple pages, ensure that you are
            // handling the hardware Back button by registering for the
            // Windows.Phone.UI.Input.HardwareButtons.BackPressed event.
            // If you are using the NavigationHelper provided by some templates,
            // this event is handled for you.

   
        }

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            LoadState(e.Parameter);
            if (HasPortrait)
            {
                _currentOrientations = DisplayInformation.AutoRotationPreferences;
                DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait
                                                            | DisplayOrientations.Landscape
                                                            | DisplayOrientations.LandscapeFlipped
                                                            | DisplayOrientations.PortraitFlipped;

                // Handle orientation changes
                DisplayInformation.GetForCurrentView().OrientationChanged += this.OnOrientationChanged;
                this.TransitionStoryboardState();
            }
        }

        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            _dataTransferManager = DataTransferManager.GetForCurrentView();
            _dataTransferManager.DataRequested += OnDataRequested;

            _navigationHelper.OnNavigatedTo(e);

            if (YouTubeChannelModel != null)
            {
                await YouTubeChannelModel.LoadItemsAsync();
                YouTubeChannelModel.SelectItem(e.Parameter);

                YouTubeChannelModel.ViewType = ViewTypes.Detail;
            }

            ytViewer.OnNavigatedTo();

            // Allow this page to rotate
            _currentOrientations = DisplayInformation.AutoRotationPreferences;
            DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait
                                                        | DisplayOrientations.Landscape
                                                        | DisplayOrientations.LandscapeFlipped
                                                        | DisplayOrientations.PortraitFlipped;
        }

        /// <summary>
        /// Gets a value that indicates if the aspect ratio is changing as part of the orientation change.
        /// </summary>
        /// <param name="oldOrientation">
        /// The old orientation.
        /// </param>
        /// <param name="newOrientation">
        /// The new orientation.
        /// </param>
        /// <returns>
        /// <c>true</c> if the aspect ratio is changing as part of the orientation change; otherwise <c>false</c>.
        /// </returns>
        public static bool IsAspectChanging(DisplayOrientations oldOrientation, DisplayOrientations newOrientation)
        {
            // Going from landscape to portrait?
            if ((oldOrientation == DisplayOrientations.Landscape) ||
                (oldOrientation == DisplayOrientations.LandscapeFlipped))
            {
                if ((newOrientation == DisplayOrientations.Portrait) ||
                    (newOrientation == DisplayOrientations.PortraitFlipped))
                {
                    return true;
                }
            }

            // Going from portrait to landscape?
            if ((oldOrientation == DisplayOrientations.Portrait) ||
                (oldOrientation == DisplayOrientations.PortraitFlipped))
            {
                if ((newOrientation == DisplayOrientations.Landscape) ||
                    (newOrientation == DisplayOrientations.LandscapeFlipped))
                {
                    return true;
                }
            }

            // Nope
            return false;
        }

        private SimpleOrientation ConvertDisplayOrientationToSimpleOrientation(DisplayOrientations orientation)
        {
            SimpleOrientation result;
            switch (orientation)
            {
                case DisplayOrientations.Landscape:
                    result = SimpleOrientation.NotRotated;
                    break;
                case DisplayOrientations.PortraitFlipped:
                    result = SimpleOrientation.Rotated90DegreesCounterclockwise;
                    break;
                case DisplayOrientations.LandscapeFlipped:
                    result = SimpleOrientation.Rotated180DegreesCounterclockwise;
                    break;
                case DisplayOrientations.Portrait:
                default:
                    result = SimpleOrientation.Rotated270DegreesCounterclockwise;
                    break;
            }

            // Above assumes landscape; offset is needed if native orientation is portrait
            if (_displayInformation.NativeOrientation == DisplayOrientations.Portrait)
            {
                result = AddOrientations(result, SimpleOrientation.Rotated90DegreesCounterclockwise);
            }

            return result;
        }

        private static DisplayOrientation ToOrientation(DisplayOrientations orientations)
        {
            var result = DisplayOrientation.Default;
            if ((orientations & DisplayOrientations.Landscape) != 0)
                result |= DisplayOrientation.LandscapeLeft;
            if ((orientations & DisplayOrientations.LandscapeFlipped) != 0)
                result |= DisplayOrientation.LandscapeRight;
            if ((orientations & DisplayOrientations.Portrait) != 0)
                result |= DisplayOrientation.Portrait;
            if ((orientations & DisplayOrientations.PortraitFlipped) != 0)
                result |= DisplayOrientation.PortraitDown;

            return result;
        }

 /// <summary>
 /// finds the degree of rotation to rotate the image/video preview
 /// </summary>
 /// <param name="displayOrientation"></param>
 /// the current phone orientation
 /// <param name="counterclockwise"></param>
 /// checks if rotation should be done clockwise or counterclockwise
 /// <returns></returns>
 private VideoRotation VideoRotationLookup(DisplayOrientations displayOrientation, bool counterclockwise)
 {
     switch (displayOrientation)
     {
         case DisplayOrientations.Landscape:
             return VideoRotation.None;
         case DisplayOrientations.Portrait:
             return (counterclockwise) ? VideoRotation.Clockwise270Degrees : VideoRotation.Clockwise90Degrees;
         case DisplayOrientations.LandscapeFlipped:
             return VideoRotation.Clockwise180Degrees;
         case DisplayOrientations.PortraitFlipped:
             return (counterclockwise) ? VideoRotation.Clockwise90Degrees :
             VideoRotation.Clockwise270Degrees;
         default:
             return VideoRotation.None;
     }
 }

        /// <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;
        }

        /// <summary>
        /// Calculates the size and location of the rectangle that contains the preview stream within the preview control, when the scaling mode is Uniform
        /// </summary>
        /// <param name="previewResolution">The resolution at which the preview is running</param>
        /// <param name="previewControl">The control that is displaying the preview using Uniform as the scaling mode</param>
        /// <param name="displayOrientation">The orientation of the display, to account for device rotation and changing of the CaptureElement display ratio compared to the camera stream</param>
        /// <returns></returns>
        public static Rect GetPreviewStreamRectInControl(VideoEncodingProperties previewResolution, CaptureElement previewControl, DisplayOrientations displayOrientation)
        {
            var result = new Rect();

            // In case this function is called before everything is initialized correctly, return an empty result
            if (previewControl == null || previewControl.ActualHeight < 1 || previewControl.ActualWidth < 1 ||
                previewResolution == null || previewResolution.Height == 0 || previewResolution.Width == 0)
            {
                return result;
            }

            var streamWidth = previewResolution.Width;
            var streamHeight = previewResolution.Height;

            // For portrait orientations, the width and height need to be swapped
            if (displayOrientation == DisplayOrientations.Portrait || displayOrientation == DisplayOrientations.PortraitFlipped)
            {
                streamWidth = previewResolution.Height;
                streamHeight = previewResolution.Width;
            }

            // Start by assuming the preview display area in the control spans the entire width and height both (this is corrected in the next if for the necessary dimension)
            result.Width = previewControl.ActualWidth;
            result.Height = previewControl.ActualHeight;

            // If UI is "wider" than preview, letterboxing will be on the sides
            if ((previewControl.ActualWidth / previewControl.ActualHeight > streamWidth / (double)streamHeight))
            {
                var scale = previewControl.ActualHeight / streamHeight;
                var scaledWidth = streamWidth * scale;

                result.X = (previewControl.ActualWidth - scaledWidth) / 2.0;
                result.Width = scaledWidth;
            }
            else // Preview stream is "wider" than UI, so letterboxing will be on the top+bottom
            {
                var scale = previewControl.ActualWidth / streamWidth;
                var scaledHeight = streamHeight * scale;

                result.Y = (previewControl.ActualHeight - scaledHeight) / 2.0;
                result.Height = scaledHeight;
            }

            return result;
        }

 private void UpdateVisibility(DisplayOrientations orientation)
 {
     if (HideOnLandscape)
     {
         if (orientation == Windows.Graphics.Display.DisplayOrientations.Landscape ||
            orientation == Windows.Graphics.Display.DisplayOrientations.LandscapeFlipped)
         {
             this.Visibility = Visibility.Collapsed;
         }
         else if (orientation == Windows.Graphics.Display.DisplayOrientations.Portrait ||
                 orientation == Windows.Graphics.Display.DisplayOrientations.PortraitFlipped)
         {
             this.Visibility = Visibility.Visible;
         }
     }
 }

        /// <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();
        }

		static DeviceOrientation GetDeviceOrientation(DisplayOrientations orientations)
		{
			switch (orientations)
			{
				case DisplayOrientations.Landscape:
				case DisplayOrientations.LandscapeFlipped:
					return DeviceOrientation.Landscape;

				case DisplayOrientations.Portrait:
				case DisplayOrientations.PortraitFlipped:
					return DeviceOrientation.Portrait;

				default:
				case DisplayOrientations.None:
					return DeviceOrientation.Other;
			}
		}

 /// <summary>
 /// Initializes a new DetectorVideoSink.
 /// </summary>
 /// <param name="detector">The CaptureSourceMarkerDetector to use.</param>
 public UWPMediaSink(CaptureSourceMarkerDetector detector)
 {
     this.detector = detector;
     listener.ConnectionReceived += Listener_ConnectionReceived;
     displayOrientation = displayInformation.CurrentOrientation;
     displayInformation.OrientationChanged += DisplayInformation_OrientationChanged;
 }

 private void DisplayInformation_OrientationChanged(DisplayInformation sender, Object args)
 {
     displayOrientation = sender.CurrentOrientation;
     if (capturing)
     {
         setPreviewRotation();
     }
 }

		private async void PageLoaded(object sender, RoutedEventArgs e)
		{
			_displayOrientation = _displayInformation.CurrentOrientation;
			await InitializeCameraAsync();
			StorageFile sf = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///wordlist.txt", UriKind.Absolute));
			var _words = await FileIO.ReadLinesAsync(sf);
			propertySet["tolerance"] = 0.78;
			propertySet["hue"] = 320;
			propertySet["dictionary"] = _words;
			await _mediaCapture.AddVideoEffectAsync(new VideoEffectDefinition(typeof(TresholdVideoEffect).FullName, propertySet), MediaStreamType.VideoPreview);
			var timer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(400) };
			var textblockes = new List<TextBlock>();
			timer.Tick += (s, agrs) =>
			{
				List<Point> centers = new List<Point>();
				if (propertySet.ContainsKey("result"))
					Result.Text = propertySet["result"].ToString();
				if (propertySet.ContainsKey("centers"))
					centers = propertySet["centers"] as List<Point>;
				centers = centers.ToList();
				if (!centers.Any())
					return;
				if (textblockes.Count == centers.Count)
				{
					for (int i = 0; i < centers.Count; i++)
					{
						textblockes[i].Margin = new Thickness(0, centers[i].Y, centers[i].X, 0);
					}
				}
				else
				{
					foreach(TextBlock text in textblockes)
					{
						canvas.Children.Remove(text);
					}

					textblockes.Clear();

					for (int i = 0; i < centers.Count; i++)
					{
						var textblock = new TextBlock
						{
							Text = i.ToString(),
							Foreground = new SolidColorBrush(Colors.White),
							FontSize = 24,
							Margin = new Thickness(0, centers[i].Y, centers[i].X, 0)
						};
						canvas.Children.Add(textblock);
						textblockes.Add(textblock);
					}
				}


			};
			timer.Start();
		}

        private async void DisplayInformation_OrientationChanged(DisplayInformation sender, object args)
        {
            _displayOrientation = sender.CurrentOrientation;

            if (_isPreviewing)
            {
                await SetPreviewRotationAsync();
            }
        }