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; } }
/// <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; } }
protected override async void OnNavigatedTo(NavigationEventArgs e) { if (orientationSensor != null) { deviceOrientation = orientationSensor.GetCurrentOrientation(); } await InitializeCameraAsync(); RegisterEventHandlers(); }
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; } }
/// <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); } }
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); } }
/// <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); } }
public InCall() { this.InitializeComponent(); this.DataContext = new InCallModel(); askingVideo = false; if (LinphoneManager.Instance.IsVideoAvailable) { StartVideoStream(); VideoGrid.Visibility = Visibility.Collapsed; } if (LinphoneManager.Instance.Core.CurrentCall.State == CallState.StreamsRunning) { Status.Text = "00:00:00"; } displayOrientation = ApplicationView.GetForCurrentView().Orientation; displayInformation = DisplayInformation.GetForCurrentView(); deviceOrientation = SimpleOrientation.NotRotated; orientationSensor = SimpleOrientationSensor.GetDefault(); if (orientationSensor != null) { deviceOrientation = orientationSensor.GetCurrentOrientation(); SetVideoOrientation(); orientationSensor.OrientationChanged += OrientationSensor_OrientationChanged; } buttons.HangUpClick += buttons_HangUpClick; buttons.StatsClick += buttons_StatsClick; buttons.CameraClick += buttons_CameraClick; buttons.PauseClick += buttons_PauseClick; buttons.SpeakerClick += buttons_SpeakerClick; buttons.MuteClick += buttons_MuteClick; buttons.VideoClick += buttons_VideoClick; buttons.BluetoothClick += buttons_BluetoothClick; buttons.DialpadClick += buttons_DialpadClick; // Handling event when app will be suspended Application.Current.Suspending += new SuspendingEventHandler(App_Suspended); Application.Current.Resuming += new EventHandler <object>(App_Resumed); pausedCall = null; }
async Task SetupUIAsync() { // Lock page to landscape to prevent the capture element from rotating DisplayInformation.AutoRotationPreferences = DisplayOrientations.Landscape; // Hide status bar if (ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar")) { await Windows.UI.ViewManagement.StatusBar.GetForCurrentView().HideAsync(); } displayOrientation = displayInformation.CurrentOrientation; if (orientationSensor != null) { deviceOrientation = orientationSensor.GetCurrentOrientation(); } RegisterEventHandlers(); }
}//end onNavigatedTo() //This event handler is triggered when the orientation of the phone changes, because the method uses the //async keyword it will happen asynchronously. Hence allowing the application to continue with other tasks while this //method is being executed in a seperate thread. //On this page we want the orientation to remain in portrait no matter what direction the phone has been flipped in private async void OrientationChanged(object sender, SimpleOrientationSensorOrientationChangedEventArgs e) { await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { SimpleOrientation orientation = e.Orientation; //Here we retrieve the current orientation of the sensor switch (orientation) { case SimpleOrientation.NotRotated: //If the phone isnt being rotated (portrait) //Portrait DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait; //Set orientation to portrait break; case SimpleOrientation.Rotated90DegreesCounterclockwise: //if rotated 90degrees to the left //Landscape DisplayInformation.AutoRotationPreferences = DisplayOrientations.Portrait; //set orientation to portrait break; } }); }
private string GetText(SimpleOrientation orientation) { switch (orientation) { case SimpleOrientation.Faceup: return("Face-up"); case SimpleOrientation.Facedown: return("Face-down"); case SimpleOrientation.NotRotated: return("Not rotated"); case SimpleOrientation.Rotated90DegreesCounterclockwise: return("Rotated 90° counter-clockwise"); case SimpleOrientation.Rotated180DegreesCounterclockwise: return("Rotated 180° counter-clockwise"); case SimpleOrientation.Rotated270DegreesCounterclockwise: return("Rotated 270° counter-clockwise"); default: return("Unknown"); } }
public override void readData(IMethodResult oResult) { Dictionary <string, string> result = new Dictionary <string, string>(); try { _screenOrientation = SimpleOrientationSensor.GetDefault().GetCurrentOrientation(); result.Add("status", SENSOR_STATUS_OK); switch (_screenOrientation) { case SimpleOrientation.Faceup: result.Add("deviceorientation_value", NORMAL); break; case SimpleOrientation.Rotated180DegreesCounterclockwise: result.Add("deviceorientation_value", UPSIDE_DOWN); break; case SimpleOrientation.Rotated90DegreesCounterclockwise: result.Add("deviceorientation_value", LANDSCAPE_RIGHT); break; case SimpleOrientation.Rotated270DegreesCounterclockwise: result.Add("deviceorientation_value", LANDSCAPE_LEFT); break; default: result.Add("deviceorientation_value", NORMAL); break; } result.Add("type", type); } catch (Exception e) { _screenOrientation = SimpleOrientation.Faceup; result.Add("status", SENSOR_STATUS_ERROR); result.Add("message", e.Message); } oResult.set(result); }
private void LaunchTimer_Click(object sender, RoutedEventArgs e) { var timer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(1000) }; timer.Tick += (s, a) => { var currentOrientation = SimpleOrientationSensor.GetDefault().GetCurrentOrientation(); if (currentOrientation == _orientation) { return; } _orientation = currentOrientation; textBlock.Text += PrintOrientation("timer", currentOrientation); }; timer.Start(); }
/// <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(); }
void Broadcast(IObserver <DeviceOrientation> ob, SimpleOrientation orientation) { switch (orientation) { case SimpleOrientation.NotRotated: ob.OnNext(DeviceOrientation.LandscapeLeft); break; case SimpleOrientation.Rotated90DegreesCounterclockwise: ob.OnNext(DeviceOrientation.Portrait); break; case SimpleOrientation.Rotated180DegreesCounterclockwise: ob.OnNext(DeviceOrientation.LandscapeRight); break; case SimpleOrientation.Rotated270DegreesCounterclockwise: ob.OnNext(DeviceOrientation.PortraitUpsideDown); break; } }
private async void Sensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args) { SimpleOrientation orientation = args.Orientation; await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { // Switch the placement of the buttons based on an orientation change. if (SimpleOrientation.NotRotated == orientation) { Panel1.Visibility = Visibility.Collapsed; Panel2.Visibility = Visibility.Collapsed; Panel3.Visibility = Visibility.Collapsed; } // If not in portrait, move buttonList content to visible row and column. else { Panel1.Visibility = Visibility.Visible; Panel2.Visibility = Visibility.Visible; Panel3.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() { // 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> /// Initializes the MediaCapture, registers events, gets camera device information for mirroring and rotating, starts preview and unlocks the UI /// </summary> /// <returns></returns> public async Task Initialize(string faceKey, string emotionKey) { Debug.WriteLine("Initialize-Facedetector"); _faceKey = faceKey; _emotionKey = emotionKey; _faceMetaData = new FaceMetaData(_faceKey, _emotionKey); _faceMetaData.DetectedFaces += FaceMetaData_DetectedFaces; _displayOrientation = _displayInformation.CurrentOrientation; if (_orientationSensor != null) { _deviceOrientation = _orientationSensor.GetCurrentOrientation(); } // Clear any rectangles that may have been left over from a previous instance of the effect FacesCanvas.Children.Clear(); DeviceInformationCollection allVideoDevices = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture); CameraListBox.ItemsSource = allVideoDevices; }
async Task SetupUIAsync() { // Lock page to landscape to prevent the capture element from rotating DisplayInformation.AutoRotationPreferences = DisplayOrientations.Landscape; // Hide status bar if (ApiInformation.IsTypePresent("Windows.UI.ViewManagement.StatusBar")) { await Windows.UI.ViewManagement.StatusBar.GetForCurrentView().HideAsync(); } displayOrientation = displayInformation.CurrentOrientation; if (orientationSensor != null) { deviceOrientation = orientationSensor.GetCurrentOrientation(); } RegisterEventHandlers(); var picturesLibrary = await StorageLibrary.GetLibraryAsync(KnownLibraryId.Pictures); // Fallback to local app storage if no pictures library captureFolder = picturesLibrary.SaveFolder ?? ApplicationData.Current.LocalFolder; }
public static SimpleOrientation ToSimpleOrientation(this DisplayInformation displayInformation, SimpleOrientation deviceOrientation, bool isFlipped) { var result = deviceOrientation; if (displayInformation.NativeOrientation == DisplayOrientations.Portrait) { switch (result) { case SimpleOrientation.Rotated90DegreesCounterclockwise: result = SimpleOrientation.NotRotated; break; case SimpleOrientation.Rotated180DegreesCounterclockwise: result = SimpleOrientation.Rotated90DegreesCounterclockwise; break; case SimpleOrientation.Rotated270DegreesCounterclockwise: result = SimpleOrientation.Rotated180DegreesCounterclockwise; break; case SimpleOrientation.NotRotated: result = SimpleOrientation.Rotated270DegreesCounterclockwise; break; } } if (isFlipped) { switch (result) { case SimpleOrientation.Rotated90DegreesCounterclockwise: return(SimpleOrientation.Rotated270DegreesCounterclockwise); case SimpleOrientation.Rotated270DegreesCounterclockwise: return(SimpleOrientation.Rotated90DegreesCounterclockwise); } } return(result); }
private static SimpleOrientation ToSimpleOrientationRelativeToPortrait(int orientation, SimpleOrientation previousOrientation) { // https://developer.android.com/reference/android/view/OrientationEventListener.html // orientation parameter is in degrees, ranging from 0 to 359. // orientation is: // - 0 degrees when the device is oriented in its natural position // - 90 degrees when its left side is at the top // - 180 degrees when it is upside down // - 270 degrees when its right side is to the top // - ORIENTATION_UNKNOWN when the device is close to flat and the orientation cannot be determined. if (orientation == OrientationEventListener.OrientationUnknown) { // device is close to flat then we push a face-up by default. return(SimpleOrientation.Faceup); } if (DefaultDeviceOrientation == Orientation.Landscape) { // we offset the rotation by 270 degrees because // we want an orientation relative to Portrait orientation = (orientation + 270) % 360; } // Ensures orientation only changes when within close range to new orientation. // Empirical testing on an Android 6.0 device indicates that orientation changes // when within about 22.5° (90° / 4) of a new orientation (0°, 90°, 180°, 270°). var threshold = 22.5; if (Math.Abs(orientation - 0) < threshold || Math.Abs(orientation - 360) < threshold) { // natural position return(SimpleOrientation.NotRotated); } else if (Math.Abs(orientation - 90) < threshold) { // left side is at the top return(SimpleOrientation.Rotated270DegreesCounterclockwise); } else if (Math.Abs(orientation - 180) < threshold) { // upside down return(SimpleOrientation.Rotated180DegreesCounterclockwise); } else if (Math.Abs(orientation - 270) < threshold) { // right side is to the top return(SimpleOrientation.Rotated90DegreesCounterclockwise); } else { return(previousOrientation); } }
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; } }
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(); }
public void UpdateText(SensorData sensorData) { try { int index = sensorData._reading.Count - 1; if (sensorData._count == Sensor.currentId) { UpdateProperty(sensorData._deviceId, sensorData._deviceName, sensorData._reportInterval, sensorData._minReportInterval, sensorData._reportLatency, sensorData._category, sensorData._persistentUniqueId, sensorData._manufacturer, sensorData._model, sensorData._connectionType); } if (StackPanelSensor.Visibility == Visibility.Visible) { if (sensorData._sensorType == Sensor.ACCELEROMETER || sensorData._sensorType == Sensor.ACCELEROMETERLINEAR || sensorData._sensorType == Sensor.ACCELEROMETERGRAVITY) { double margin = 80; double x = Math.Min(1, sensorData._reading[index].value[0]); double y = Math.Min(1, sensorData._reading[index].value[1]); double square = x * x + y * y; if (square > 1) { x /= Math.Sqrt(square); y /= Math.Sqrt(square); } DisplayInformation displayInformation = DisplayInformation.GetForCurrentView(); if (displayInformation.NativeOrientation == DisplayOrientations.Landscape) { switch (displayInformation.CurrentOrientation) { case DisplayOrientations.Landscape: EllipseAccelerometer.Margin = new Thickness() { Left = margin * x, Bottom = margin * y }; break; case DisplayOrientations.Portrait: EllipseAccelerometer.Margin = new Thickness() { Left = margin * y, Bottom = -margin * x }; break; case DisplayOrientations.LandscapeFlipped: EllipseAccelerometer.Margin = new Thickness() { Left = -margin * x, Bottom = -margin * y }; break; case DisplayOrientations.PortraitFlipped: EllipseAccelerometer.Margin = new Thickness() { Left = -margin * y, Bottom = margin * x }; break; } } else if (displayInformation.NativeOrientation == DisplayOrientations.Portrait) { switch (displayInformation.CurrentOrientation) { case DisplayOrientations.Landscape: EllipseAccelerometer.Margin = new Thickness() { Left = -margin * y, Bottom = margin * x }; break; case DisplayOrientations.Portrait: EllipseAccelerometer.Margin = new Thickness() { Left = margin * x, Bottom = margin * y }; break; case DisplayOrientations.LandscapeFlipped: EllipseAccelerometer.Margin = new Thickness() { Left = margin * y, Bottom = -margin * x }; break; case DisplayOrientations.PortraitFlipped: EllipseAccelerometer.Margin = new Thickness() { Left = -margin * x, Bottom = -margin * y }; break; } } } for (int i = 0; i < sensorData._reading[index].value.Length; i++) { TextBlockProperty[i].Text = sensorData._property[i]; TextBlockValue[i].Text = String.Format(" {0,5:0.00}", sensorData._reading[index].value[i]); TextBlockMinValue[i].Text = String.Format(" {0,5:0.0}", sensorData._minValue[i]); TextBlockMaxValue[i].Text = String.Format(" {0,5:0.0}", sensorData._maxValue[i]); if (sensorData._property[i].StartsWith("MagneticNorth")) { RotateTransform rotateCompass = new RotateTransform(); ImageCompass.RenderTransform = rotateCompass; rotateCompass.Angle = (-1) * Convert.ToDouble(sensorData._reading[index].value[i]); rotateCompass.CenterX = ImageCompass.ActualWidth / 2; rotateCompass.CenterY = ImageCompass.ActualHeight / 2; } else if (sensorData._property[i].StartsWith("AngularVelocityX")) { RotateTransform rotateGyrometerX = new RotateTransform() { CenterX = ImageGyrometerX.ActualWidth / 2, CenterY = ImageGyrometerX.ActualHeight / 2 }; ImageGyrometerX.RenderTransform = rotateGyrometerX; rotateGyrometerX.Angle = Math.Max(-135, Math.Min(135, Convert.ToDouble(sensorData._reading[index].value[i]))); } else if (sensorData._property[i].StartsWith("AngularVelocityY")) { RotateTransform rotateGyrometerY = new RotateTransform(); ImageGyrometerY.RenderTransform = rotateGyrometerY; rotateGyrometerY.Angle = Math.Max(-135, Math.Min(135, Convert.ToDouble(sensorData._reading[index].value[i]))); rotateGyrometerY.CenterX = ImageGyrometerY.ActualWidth / 2; rotateGyrometerY.CenterY = ImageGyrometerY.ActualHeight / 2; } else if (sensorData._property[i].StartsWith("AngularVelocityZ")) { RotateTransform rotateGyrometerZ = new RotateTransform(); ImageGyrometerZ.RenderTransform = rotateGyrometerZ; rotateGyrometerZ.Angle = Math.Max(-135, Math.Min(135, Convert.ToDouble(sensorData._reading[index].value[i]))); rotateGyrometerZ.CenterX = ImageGyrometerZ.ActualWidth / 2; rotateGyrometerZ.CenterY = ImageGyrometerZ.ActualHeight / 2; } else if (sensorData._property[i].StartsWith("Pitch")) { RotateTransform rotate = new RotateTransform() { CenterX = ImageInclinometerPitch.ActualWidth / 2, CenterY = ImageInclinometerPitch.ActualHeight / 2 }; ImageInclinometerPitch.RenderTransform = rotate; rotate.Angle = sensorData._reading[index].value[i]; } else if (sensorData._property[i].StartsWith("Roll")) { RotateTransform rotate = new RotateTransform() { CenterX = ImageInclinometerRoll.ActualWidth / 2, CenterY = ImageInclinometerRoll.ActualHeight / 2 }; ImageInclinometerRoll.RenderTransform = rotate; rotate.Angle = sensorData._reading[index].value[i]; } else if (sensorData._property[i] == "Yaw (°)") { RotateTransform rotate = new RotateTransform() { CenterX = ImageInclinometerYaw.ActualWidth / 2, CenterY = ImageInclinometerYaw.ActualHeight / 2 }; ImageInclinometerYaw.RenderTransform = rotate; rotate.Angle = -sensorData._reading[index].value[i]; } else if (sensorData._property[i] == "Illuminance (lux)") { TextBlockSensor.Text = "💡"; if (sensorData._reading[index].value[i] < 1) { TextBlockSensor.Opacity = 0.1; } else { TextBlockSensor.Opacity = Math.Min(0.1 + Math.Log(sensorData._reading[index].value[i], 2) / 10, 1); } } else if (sensorData._property[i] == "CumulativeSteps") { int value = Convert.ToInt32(sensorData._reading[index].value[i]) / 100; _plotCanvas.SetRange((value + 1) * 100, value * 100); } else if (sensorData._property[i] == "HeadingAccuracy" || sensorData._property[i] == "YawAccuracy") { MagnetometerAccuracy magnetometerAccuracy = (MagnetometerAccuracy)sensorData._reading[index].value[i]; TextBlockValue[i].Text = String.Format(" {0}", magnetometerAccuracy); } else if (sensorData._property[i] == "IsDetected") { TextBlockSensor.Text = (sensorData._reading[index].value[i] > 0.5 ? "📲" : "📱"); } else if (sensorData._property[i] == "StepKind") { PedometerStepKind pedometerStepKind = (PedometerStepKind)sensorData._reading[index].value[i]; TextBlockValue[i].Text = String.Format(" {0}", pedometerStepKind); TextBlockSensor.Text = DictionaryStepKind[pedometerStepKind]; } else if (sensorData._sensorType == Sensor.SIMPLEORIENTATIONSENSOR) { SimpleOrientation simpleOrientation = (SimpleOrientation)sensorData._reading[index].value[i]; TextBlockValue[i].Text = String.Format(" {0}", simpleOrientation).Replace("DegreesCounterclockwise", "°↺"); TextBlockMinValue[i].Text = ""; TextBlockMaxValue[i].Text = ""; } else if (sensorData._sensorType == Sensor.ACTIVITYSENSOR) { if (sensorData._reading[index].value[i] == Sensor.ACTIVITYNONE) { TextBlockValue[i].Text = "None"; } else if (sensorData._reading[index].value[i] == Sensor.ACTIVITYNOTSUPPORTED) { TextBlockValue[i].Text = "Not Supported"; } else { ActivitySensorReadingConfidence activitySensorReadingConfidence = (ActivitySensorReadingConfidence)sensorData._reading[index].value[i]; TextBlockValue[i].Text = String.Format(" {0}", activitySensorReadingConfidence); TextBlockSensor.Text = DictionaryActivity[(ActivityType)i]; } } else if (sensorData._sensorType == Sensor.LIGHTSENSOR) { if (sensorData._reading[index].value[i] == -1) { TextBlockValue[i].Text = "N/A"; TextBlockMinValue[i].Text = "N/A"; TextBlockMaxValue[i].Text = "N/A"; } } } } } catch { } }
private SimpleOrientation GetCameraOrientation(DisplayInformation displayInformation, SimpleOrientation deviceOrientation) { var result = deviceOrientation; // Account for the fact that, on portrait-first devices, the camera sensor is mounted at a 90 degree offset to the native orientation if (displayInformation.NativeOrientation == DisplayOrientations.Portrait) { switch (result) { case SimpleOrientation.Rotated90DegreesCounterclockwise: result = SimpleOrientation.NotRotated; break; case SimpleOrientation.Rotated180DegreesCounterclockwise: result = SimpleOrientation.Rotated90DegreesCounterclockwise; break; case SimpleOrientation.Rotated270DegreesCounterclockwise: result = SimpleOrientation.Rotated180DegreesCounterclockwise; break; case SimpleOrientation.NotRotated: result = SimpleOrientation.Rotated270DegreesCounterclockwise; break; } } // If the preview is being mirrored for a front-facing camera, then the rotation should be inverted if (_mirroringPreview) { // This only affects the 90 and 270 degree cases, because rotating 0 and 180 degrees is the same clockwise and counter-clockwise switch (result) { case SimpleOrientation.Rotated90DegreesCounterclockwise: return(SimpleOrientation.Rotated270DegreesCounterclockwise); case SimpleOrientation.Rotated270DegreesCounterclockwise: return(SimpleOrientation.Rotated90DegreesCounterclockwise); } } return(result); }
/// <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()); } }
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 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); }
private static SimpleOrientation AddOrientations(SimpleOrientation a, SimpleOrientation b) { var aRot = ConvertSimpleOrientationToClockwiseDegrees(a); var bRot = ConvertSimpleOrientationToClockwiseDegrees(b); var result = (aRot + bRot) % 360; return ConvertClockwiseDegreesToSimpleOrientation(result); }
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 SimpleOrientation GetCameraOrientation(DisplayInformation displayInformation, SimpleOrientation deviceOrientation) { var result = deviceOrientation; if (displayInformation.NativeOrientation == DisplayOrientations.Portrait) { switch (result) { case SimpleOrientation.Rotated90DegreesCounterclockwise: result = SimpleOrientation.NotRotated; break; case SimpleOrientation.Rotated180DegreesCounterclockwise: result = SimpleOrientation.Rotated90DegreesCounterclockwise; break; case SimpleOrientation.Rotated270DegreesCounterclockwise: result = SimpleOrientation.Rotated180DegreesCounterclockwise; break; case SimpleOrientation.NotRotated: result = SimpleOrientation.Rotated270DegreesCounterclockwise; break; } } if (_mirroringPreview) { switch (result) { case SimpleOrientation.Rotated90DegreesCounterclockwise: return(SimpleOrientation.Rotated270DegreesCounterclockwise); case SimpleOrientation.Rotated270DegreesCounterclockwise: return(SimpleOrientation.Rotated90DegreesCounterclockwise); } } return(result); }
/// <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; } }
private static SimpleOrientation ToSimpleOrientation(double gravityX, double gravityY, double gravityZ, SimpleOrientation previous) { // Ensures orientation only changes when within close range to new orientation. if (Math.Abs(gravityX) > Math.Abs(gravityY) + _threshold && Math.Abs(gravityX) > Math.Abs(gravityZ) + _threshold) { if (gravityX > 0) { return(SimpleOrientation.Rotated270DegreesCounterclockwise); } return(SimpleOrientation.Rotated90DegreesCounterclockwise); } else if (Math.Abs(gravityY) > Math.Abs(gravityX) + _threshold && Math.Abs(gravityY) > Math.Abs(gravityZ) + _threshold) { if (gravityY >= 0) { return(SimpleOrientation.Rotated180DegreesCounterclockwise); } return(SimpleOrientation.NotRotated); } else if (Math.Abs(gravityZ) > Math.Abs(gravityY) + _threshold && Math.Abs(gravityZ) > Math.Abs(gravityX) + _threshold) { if (gravityZ >= 0) { return(SimpleOrientation.Facedown); } return(SimpleOrientation.Faceup); } return(previous); }
/// <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(); }
private static PhotoOrientation ConvertOrientationToPhotoOrientation(SimpleOrientation orientation) { return(PhotoOrientation.Rotate90); }
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(); }
private static string PrintOrientation(string text, SimpleOrientation currentOrientation) { return(string.Format("\r\n[{2}] {1} orientation: {0}", currentOrientation, DateTime.Now.ToString("HH:mm:ss.ttt"), text)); }
void SetSimpleOrientationText(SimpleOrientation simpleOrientation) { this.simpleOrientation.Text = simpleOrientation.ToString(); }
private void OrientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args) { if (args.Orientation != SimpleOrientation.Faceup && args.Orientation != SimpleOrientation.Facedown) { _deviceOrientation = args.Orientation; } }
/// <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() { // 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(); }
void SetOrientationSensorText(SimpleOrientation simpleOrientation) { orientationSensorTextBlock.Text = simpleOrientation.ToString(); }
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 async void Sensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args) { SimpleOrientation orientation = args.Orientation; await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { // Switch the placement of the buttons based on an orientation change. if (SimpleOrientation.NotRotated == orientation) { //Grid.SetRow(buttonList, 1); //Grid.SetColumn(buttonList, 0); this._btnMC.Width = 86; this._btnMR.Width = 86; this._btnMMas.Width = 86; this._btnMMenos.Width = 86; this._btnMS.Width = 86; this._btnSin.Width = 0; this._btnCos.Width = 0; this._btnTan.Width = 0; this._btnLog.Width = 0; this._btnIn.Width = 0; Grid.SetColumn(_btnPorc, 0); Grid.SetRow(_btnPorc, 0); this._btnPorc.Width = 86; this._btnPorc.Height = 76; Grid.SetColumn(_btnRoot, 1); Grid.SetRow(_btnRoot, 0); Grid.SetColumn(_btnSquare, 2); Grid.SetRow(_btnSquare, 0); Grid.SetColumn(_btnByX, 3); Grid.SetRow(_btnByX, 0); Grid.SetColumn(_numSeven, 0); Grid.SetColumn(_numEight, 1); Grid.SetColumn(_numNine, 2); Grid.SetColumn(_numFour, 0); Grid.SetColumn(_numFive, 1); Grid.SetColumn(_numSix, 2); Grid.SetColumn(_numOne, 0); Grid.SetColumn(_numTwo, 1); Grid.SetColumn(_numThree, 2); Grid.SetColumn(_numZero, 1); Grid.SetRowSpan(_numZero, 1); Grid.SetColumn(_btnDot, 2); Grid.SetColumn(_btnCE, 0); Grid.SetRow(_btnCE, 1); this._btnCE.Width = 86; this._btnCE.Height = 76; Grid.SetColumn(_btnC, 1); Grid.SetRow(_btnC, 1); Grid.SetColumn(_btnDEL, 2); Grid.SetRow(_btnDEL, 1); Grid.SetColumn(_btnNeg, 0); Grid.SetRow(_btnNeg, 5); Grid.SetColumn(_btnEquals, 3); Grid.SetRow(_btnEquals, 5); this._btnEquals.Width = Double.NaN; this._btnEquals.Height = Double.NaN; Grid.SetColumn(_btnDiv, 3); Grid.SetRow(_btnDiv, 1); Grid.SetColumn(_btnMult, 3); Grid.SetRow(_btnMult, 2); Grid.SetColumn(_btnMinus, 3); Grid.SetRow(_btnMinus, 3); Grid.SetColumn(_btnPlus, 3); Grid.SetRow(_btnPlus, 4); this._btnPlus.Width = Double.NaN; this._btnPlus.Height = Double.NaN; } // If not in portrait, move buttonList content to visible row and column. else { //Grid.SetRow(buttonList, 0); //Grid.SetColumn(buttonList, 1); this._btnMC.Width = 0; this._btnMR.Width = 0; this._btnMMas.Width = 0; this._btnMMenos.Width = 0; this._btnMS.Width = 0; this._btnSin.Width = 86; this._btnCos.Width = 86; this._btnTan.Width = 86; this._btnLog.Width = 86; this._btnIn.Width = 86; Grid.SetColumn(_btnPorc, 0); Grid.SetRow(_btnPorc, 5); this._btnPorc.Width = Double.NaN; this._btnPorc.Height = Double.NaN; Grid.SetColumn(_btnRoot, 0); Grid.SetRow(_btnRoot, 4); Grid.SetColumn(_btnSquare, 0); Grid.SetRow(_btnSquare, 3); Grid.SetColumn(_btnByX, 0); Grid.SetRow(_btnByX, 2); Grid.SetColumn(_numSeven, 1); Grid.SetColumn(_numEight, 2); Grid.SetColumn(_numNine, 3); Grid.SetColumn(_numFour, 1); Grid.SetColumn(_numFive, 2); Grid.SetColumn(_numSix, 3); Grid.SetColumn(_numOne, 1); Grid.SetColumn(_numTwo, 2); Grid.SetColumn(_numThree, 3); Grid.SetColumn(_numZero, 2); Grid.SetRowSpan(_numZero, 2); Grid.SetColumn(_btnDot, 3); Grid.SetColumn(_btnC, 5); Grid.SetRow(_btnC, 2); Grid.SetColumn(_btnCE, 5); Grid.SetRow(_btnCE, 3); this._btnCE.Width = Double.NaN; this._btnCE.Height = Double.NaN; Grid.SetColumn(_btnDEL, 5); Grid.SetRow(_btnDEL, 4); Grid.SetColumn(_btnNeg, 1); Grid.SetRow(_btnNeg, 5); Grid.SetColumn(_btnEquals, 5); Grid.SetRow(_btnEquals, 5); this._btnEquals.Width = Double.NaN; this._btnEquals.Height = Double.NaN; Grid.SetColumn(_btnDiv, 4); Grid.SetRow(_btnDiv, 2); Grid.SetColumn(_btnMult, 4); Grid.SetRow(_btnMult, 3); Grid.SetColumn(_btnMinus, 4); Grid.SetRow(_btnMinus, 4); Grid.SetColumn(_btnPlus, 4); Grid.SetRow(_btnPlus, 5); this._btnPlus.Width = 95; this._btnPlus.Height = Double.NaN; } }); }
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; // } //} }
/// <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; }
internal SimpleTelemetry(int x, int y, SimpleOrientation o) { this.X = x; this.Y = y; this.Orientation = o; }
/// <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; } }
/// <summary> /// Registers event handlers for orientation sensors and hardware buttons. /// </summary> private void RegisterEventHandlers() { // If there is a hardware camera button, register for that event if (ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons")) { HardwareButtons.CameraPressed += HardwareButtons_CameraPressed; } // If there is an orientation sensor present on the device, register for notifications if (_orientationSensor != null) { _orientationSensor.OrientationChanged += OrientationSensor_OrientationChanged; _deviceOrientation = _orientationSensor.GetCurrentOrientation(); // Update the orientation of the capture button UpdateButtonOrientation(); } // TODO: This may be removed if not needed. // _displayOrientation = _displayInformation.CurrentOrientation; _displayInformation.OrientationChanged += DisplayInformation_OrientationChanged; _systemMediaControls.PropertyChanged += SystemMediaControls_PropertyChanged; }