private void compass_ReadingChanged(object sender, Windows.Devices.Sensors.CompassReadingChangedEventArgs e)
{
System.Windows.Application.Current.Dispatcher.BeginInvoke((Action) delegate
{
CompassReading = e.Reading;
});
}
public CompassSensorReading(CompassReading compassReading)
{
HeadingAccuracy = compassReading.HeadingAccuracy;
MagneticHeading = compassReading.MagneticHeading;
MagnetometerReading = compassReading.MagnetometerReading;
Timestamp = compassReading.Timestamp;
TrueHeading = compassReading.TrueHeading;
}
static HeadingNorth ConvertToHeadingNorth(CompassReading reading)
{
return(new HeadingNorth
{
Magnetic = reading.HeadingMagneticNorth,
True = reading.HeadingTrueNorth ?? 0.0
});
}
public CompassReadingEx(CompassReading reading)
: this()
{
this.HeadingAccuracy = reading.HeadingAccuracy;
this.MagneticHeading = reading.MagneticHeading;
this.Timestamp = reading.Timestamp;
this.TrueHeading = reading.TrueHeading;
}
public CompassSensorReading(CompassReading compassReading)
{
HeadingAccuracy = compassReading.HeadingAccuracy;
MagneticHeading = compassReading.MagneticHeading;
MagnetometerReading = compassReading.MagnetometerReading;
Timestamp = compassReading.Timestamp;
TrueHeading = compassReading.TrueHeading;
}
private async void ReadingChanged(Compass sender, CompassReadingChangedEventArgs args)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
CompassReading reading = args.Reading;
double headingMagneticNorth = reading.HeadingMagneticNorth;
MagneticNorthHeading.Text = String.Format("{0,5:0.0}", headingMagneticNorth);
if (reading.HeadingTrueNorth != null)
{
double?headingTrueNorth = reading.HeadingTrueNorth.Value;
double diff = Math.Abs(headingTrueNorth.Value - headingMagneticNorth);
DiffTrueMag.Text = String.Format("Diff: {0,5:0.0}", diff);
}
if (_lockAzimuth)
{
_runtimeSettings.Azimuth = headingMagneticNorth;
_lockAzimuth = false;
}
RotateTransform rt = new RotateTransform {
Angle = 360.0 - headingMagneticNorth
};
CompassRose.RenderTransform = rt;
CompassNeedle.RenderTransform = _runtimeSettings.Azimuth < 0
? rt
: new RotateTransform {
Angle = _runtimeSettings.Azimuth - headingMagneticNorth
};
String accuracy = "Accurracy: ";
switch (reading.HeadingAccuracy)
{
case MagnetometerAccuracy.Unreliable:
accuracy += "Unreliable";
break;
case MagnetometerAccuracy.Approximate:
accuracy += "Approximate";
break;
case MagnetometerAccuracy.High:
accuracy += "High";
break;
case MagnetometerAccuracy.Unknown:
accuracy += "Unknown";
break;
default:
accuracy += "No data";
break;
}
AccurracyTB.Text = accuracy;
});
}
private string GetCompassResult(CompassReading reading)
{
var sb = new StringBuilder();
sb.AppendFormat("heading accuracy: {0}\n", reading.HeadingAccuracy);
sb.AppendFormat("magnetic north: {0}\n", reading.HeadingMagneticNorth);
sb.AppendFormat("true north: {0}\n", reading.HeadingTrueNorth);
return(sb.ToString());
}
private void HeadingChanged(CompassReadingChangedEventArgs args)
{
_lastKnownHeading = args.Reading;
if (ShowUserOnMap)
{
SelfMarker.IsArrowVisible = true;
SelfMarker.RotationDegrees = args.Reading.HeadingMagneticNorth;
}
}
private void SetCompassReading(CompassReading reading)
{
this.DefaultViewModel["CompassData"] =
new
{
MagneticNorth = reading.HeadingMagneticNorth,
TrueNorth = reading.HeadingTrueNorth,
Accuracy = reading.HeadingAccuracy
};
}
/// <summary>
/// Formats current coordinates into JSON format
/// </summary>
/// <returns>Coordinates in JSON format</returns>
private string GetHeadingFormatted(CompassReading reading)
{
// NOTE: timestamp is generated on the JS side, to avoid issues with format conversions
string result = String.Format("\"magneticHeading\":{0},\"headingAccuracy\":{1},\"trueHeading\":{2}",
reading.MagneticHeading.ToString("0.0", CultureInfo.InvariantCulture),
reading.HeadingAccuracy.ToString("0.0", CultureInfo.InvariantCulture),
reading.TrueHeading.ToString("0.0", CultureInfo.InvariantCulture));
return("{" + result + "}");
}
private async void OnCompassReadingChanged(Compass sender, CompassReadingChangedEventArgs args)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
CompassReading reading = args.Reading;
if (reading.HeadingTrueNorth.HasValue)
{
CanvasCtrl.Invalidate();
}
});
}
/// <summary>
/// Formats current coordinates into JSON format
/// </summary>
/// <returns>Coordinates in JSON format</returns>
private string GetHeadingFormatted(CompassReading reading)
{
string result = String.Format("\"magneticHeading\":{0},\"headingAccuracy\":{1},\"trueHeading\":{2},\"timestamp\":{3}",
reading.MagneticHeading.ToString("0.0", CultureInfo.InvariantCulture),
reading.HeadingAccuracy.ToString("0.0", CultureInfo.InvariantCulture),
reading.TrueHeading.ToString("0.0", CultureInfo.InvariantCulture),
reading.Timestamp.UtcTicks.ToString());
result = "{" + result + "}";
return(result);
}
private async void OnCompassReadingChanged(Compass sender, CompassReadingChangedEventArgs args)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
//https://docs.microsoft.com/en-us/windows/uwp/devices-sensors/sensor-orientation
CompassReading reading = args.Reading;
if (reading.HeadingTrueNorth.HasValue)
{
CanvasCtrl.Invalidate();
}
});
}
/// <summary>
/// This is the event handler for Compass' ReadingChanged events.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async private void ReadingChanged(object sender, CompassReadingChangedEventArgs e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CompassReading reading = e.Reading;
Heading = e.Reading;
// Calibrate if needed
if (reading.HeadingAccuracy != MagnetometerAccuracy.High)
{
calibrationBar.RequestCalibration(reading.HeadingAccuracy);
}
if (mapState == MapPositionState.FollowAndRotate)
{
GeolocationPin.Heading = 0;
MapMain.Heading = (double)reading.HeadingTrueNorth;
}
else
{
// This has to be the negative
GeolocationPin.Heading = (int)(MapMain.Heading - reading.HeadingTrueNorth.Value);
}
/*ScenarioOutput_MagneticNorth.Text = String.Format("{0,5:0.00}", reading.HeadingMagneticNorth);
* if (reading.HeadingTrueNorth != null)
* {
* ScenarioOutput_TrueNorth.Text = String.Format("{0,5:0.00}", reading.HeadingTrueNorth);
* }
* else
* {
* ScenarioOutput_TrueNorth.Text = "No data";
* }
* switch (reading.HeadingAccuracy)
* {
* case MagnetometerAccuracy.Unknown:
* ScenarioOutput_HeadingAccuracy.Text = "Unknown";
* break;
* case MagnetometerAccuracy.Unreliable:
* ScenarioOutput_HeadingAccuracy.Text = "Unreliable";
* break;
* case MagnetometerAccuracy.Approximate:
* ScenarioOutput_HeadingAccuracy.Text = "Approximate";
* break;
* case MagnetometerAccuracy.High:
* ScenarioOutput_HeadingAccuracy.Text = "High";
* break;
* default:
* ScenarioOutput_HeadingAccuracy.Text = "No data";
* break;
* }*/
});
}
private void OnCurrentValueChanged(CompassReading e)
{
EventHandler <CompassReading> handler = CurrentValueChanged;
if (handler != null)
{
var task = Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
handler(this, e));
task.AsTask().Wait();
}
}
private void CompassReadingChanged(object sender, CompassReadingChangedEventArgs e)
{
m_compassReading = e.Reading;
string val = "(none)";
if (m_compassReading != null)
{
val = Math.Round(Adjust90(m_compassReading.HeadingMagneticNorth), 0).ToString() + "°";
}
Dispatcher.BeginInvoke(() => { compassText.Text = "Compass: " + val; });
}
void ReadCompassData()
{
if (Compass.IsSupported)
{
CompassReading reading = compassSensor.CurrentValue;
Vector3 magnetic = reading.MagnetometerReading;
compassX.Text = "" + magnetic.X;
compassY.Text = "" + magnetic.Y;
compassZ.Text = "" + magnetic.Z;
heading.Text = string.Format("Compass (µT) : Heading {0} +/- {1} degrees", reading.TrueHeading, reading.HeadingAccuracy);
}
}
private void UpdateUI(CompassReading compassReading)
{
magneticValue.Text = compassReading.MagneticHeading.ToString("0.00");
trueValue.Text = compassReading.TrueHeading.ToString("0.00");
magneticLine.X2 = magneticLine.X1 - (200 * Math.Sin(MathHelper.ToRadians((float)compassReading.MagneticHeading)));
magneticLine.Y2 = magneticLine.Y1 - (200 * Math.Cos(MathHelper.ToRadians((float)compassReading.MagneticHeading)));
xBlock.Text = "X: " + compassReading.MagnetometerReading.X.ToString("0.00");
yBlock.Text = "Y: " + compassReading.MagnetometerReading.Y.ToString("0.00");
zBlock.Text = "Z: " + compassReading.MagnetometerReading.Z.ToString("0.00");
}
private async void Compass_ReadingChanged(Compass sender, CompassReadingChangedEventArgs e)
{
CompassReading reading = e.Reading;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (reading.HeadingTrueNorth.HasValue)
{
trueNorth.Text = string.Format("{0,5:0.00}", (double)reading.HeadingTrueNorth - COMPASS_ADJUSTMENT);
}
magNorth.Text = string.Format("{0,5:0.00}", reading.HeadingMagneticNorth - COMPASS_ADJUSTMENT);
});
}
private void ProcessCompass(CompassReading compassReading)
{
// Ignores the value if it's not a number or is not valid.
if (Double.IsNaN(compassReading.TrueHeading) || Double.IsNaN(compassReading.HeadingAccuracy))
{
return;
}
// Stores the new valid heading.
DeviceHeading = compassReading.TrueHeading;
DeviceHeadingAccuracy = compassReading.HeadingAccuracy;
}
private async void HeadingUpdated(object sender, CompassReading e)
{
var newTick = new TimeSpan(DateTime.Now.Ticks);
if (newTick.Subtract(tick).TotalMilliseconds > 10)
{
await
Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => { await GameMapControl.TryRotateToAsync(e.HeadingTrueNorth ?? e.HeadingMagneticNorth); });
tick = newTick;
}
}
void ReadCompassData()
{
if (compassSensor != null)
{
CompassReading reading = compassSensor.GetCurrentReading();
if (reading != null)
{
heading.Text = string.Format(
"Magnetic Heading={0:F0}° True Heading={1:F0}°",
reading.HeadingMagneticNorth, reading.HeadingTrueNorth);
}
}
}
public void OnGetCompass()
{
Compass sensor = Compass.GetDefault();
if (sensor != null)
{
CompassReading reading = sensor.GetCurrentReading();
CompassInfo = $"magnetic north: {reading.HeadingMagneticNorth} real north: {reading.HeadingTrueNorth} accuracy: {reading.HeadingAccuracy}";
}
else
{
CompassInfo = "Compass not found";
}
}
private async void ReadingChanged(object sender, CompassReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CompassReading reading = e.Reading;
if (reading.HeadingMagneticNorth != null &
reading.HeadingTrueNorth != null &
reading.HeadingAccuracy != null)
{
showmsg(1);
}
});
}
void ReadCompassData()
{
if (Compass.IsSupported && compassSensor.IsDataValid)
{
CompassReading reading = compassSensor.CurrentValue;
Vector3 magnetic = reading.MagnetometerReading;
// height of control = 400; height of postive bar = 200; approximate max value = 50;
// set scale at 200/50 = 4
compassX.Value = magnetic.X;
compassY.Value = magnetic.Y;
compassZ.Value = magnetic.Z;
heading.Text = string.Format("Compass (µT) Heading {0} +/- {1} degrees", reading.TrueHeading, reading.HeadingAccuracy);
}
}
/// <summary>
/// This is the event handler for ReadingChanged events.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async private void ReadingChanged(object sender, CompassReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CompassReading reading = e.Reading;
ScenarioOutput_MagneticNorth.Text = String.Format("{0,5:0.00}", reading.HeadingMagneticNorth);
if (reading.HeadingTrueNorth != null)
{
ScenarioOutput_TrueNorth.Text = String.Format("{0,5:0.00}", reading.HeadingTrueNorth);
}
else
{
ScenarioOutput_TrueNorth.Text = "No data";
}
});
}
private async void OnGetCompass(object sender, RoutedEventArgs e)
{
Compass compass = Compass.GetDefault();
if (compass != null)
{
CompassReading reading = compass.GetCurrentReading();
this.DefaultViewModel["CompassResult"] = GetCompassResult(reading);
}
else
{
var dlg = new MessageDialog("No compass found");
await dlg.ShowAsync();
}
}
private Compass _compass; // Our app' s compass object
// This event handler writes the current compass reading to
// the textblocks on the app' s main page.
private async void ReadingChanged(object sender, CompassReadingChangedEventArgs e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
CompassReading reading = e.Reading;
textBox_Magnetic.Text = String.Format("{0,5:0.00}", reading.HeadingMagneticNorth);
if (reading.HeadingTrueNorth.HasValue)
{
textBox_True.Text = String.Format("{0,5:0.00}", reading.HeadingTrueNorth);
}
else
{
textBox_True.Text = "No reading.";
}
});
}
private async void CompassChanged(CompassReading reading)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (reading.HeadingAccuracy != MagnetometerAccuracy.High)
{
CompassCalibration.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
else
{
CompassCalibration.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
_currentHeading = reading.HeadingMagneticNorth + 90;
UpdateARView();
}
});
}
async void DisplayReading(CompassReading reading)
{
await this.Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
() =>
{
// Taken from MSDN.
// https://msdn.microsoft.com/en-us/library/dn440593.aspx
// Calculate the compass heading offset based on
// the current display orientation.
var displayInfo = Windows.Graphics.Display.DisplayInformation.GetForCurrentView();
var displayOffset = 0.0d;
switch (displayInfo.CurrentOrientation)
{
case Windows.Graphics.Display.DisplayOrientations.Landscape:
displayOffset = 0;
break;
case Windows.Graphics.Display.DisplayOrientations.Portrait:
displayOffset = 270;
break;
case Windows.Graphics.Display.DisplayOrientations.LandscapeFlipped:
displayOffset = 180;
break;
case Windows.Graphics.Display.DisplayOrientations.PortraitFlipped:
displayOffset = 90;
break;
}
if (reading.HeadingTrueNorth.HasValue)
{
this.rotateTrue.Angle =
reading.HeadingTrueNorth.Value + displayOffset;
this.gridTrueNorth.Visibility = Windows.UI.Xaml.Visibility.Visible;
}
else
{
this.gridTrueNorth.Visibility = Windows.UI.Xaml.Visibility.Collapsed;
}
this.rotateMagnetic.Angle = reading.HeadingMagneticNorth + displayOffset;
}
);
}
/// <summary>
/// This is the dispatcher callback.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
//<SnippetGetCurrentReadingCS>
private void DisplayCurrentReading(object sender, object args)
{
CompassReading reading = _compass.GetCurrentReading();
if (reading != null)
{
ScenarioOutput_MagneticNorth.Text = String.Format("{0,5:0.00}", reading.HeadingMagneticNorth);
if (reading.HeadingTrueNorth != null)
{
ScenarioOutput_TrueNorth.Text = String.Format("{0,5:0.00}", reading.HeadingTrueNorth);
}
else
{
ScenarioOutput_TrueNorth.Text = "No data";
}
}
}
private async void ReadingChanged(object sender, CompassReadingChangedEventArgs e)
{
await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
CompassReading reading = e.Reading;
txtMagnetic = String.Format("{0,5:0.00}", reading.HeadingMagneticNorth);
if (reading.HeadingTrueNorth.HasValue)
{
txtNorth = String.Format("{0,5:0.00}", reading.HeadingTrueNorth);
}
}catch (Exception exc)
{
}
});
}
/// <summary>
/// Formats current coordinates into JSON format
/// </summary>
/// <returns>Coordinates in JSON format</returns>
private string GetHeadingFormatted(CompassReading reading)
{
// NOTE: timestamp is generated on the JS side, to avoid issues with format conversions
string result = String.Format("\"magneticHeading\":{0},\"headingAccuracy\":{1},\"trueHeading\":{2}",
reading.MagneticHeading.ToString("0.0", CultureInfo.InvariantCulture),
reading.HeadingAccuracy.ToString("0.0", CultureInfo.InvariantCulture),
reading.TrueHeading.ToString("0.0", CultureInfo.InvariantCulture));
return "{" + result + "}";
}
private void UpdateUI(CompassReading compassReading)
{
if (item.Position != null && _watcher != null)
{
this.currentCoordinate = _watcher.Position.Location;
double y = item.Position.Latitude - currentCoordinate.Latitude;
double x = item.Position.Longitude - currentCoordinate.Longitude;
double phi = Math.Atan2(y, x) * 100 / 1.7222; //i don't know why, but it is working!
float delta = (float)(compassReading.MagneticHeading + phi - 90);
magneticLine.X2 = magneticLine.X1 - (200 * Math.Sin(MathHelper.ToRadians(delta)));
magneticLine.Y2 = magneticLine.Y1 - (200 * Math.Cos(MathHelper.ToRadians(delta)));
magneticLine.Visibility = System.Windows.Visibility.Visible; ;
noDir.Visibility = System.Windows.Visibility.Collapsed;
}
}
private void UpdateDataUI(CompassReading data)
{
HeadingMagnN.Text = data.MagneticHeading.ToString() + "°";
HeadingGeoN.Text = data.TrueHeading.ToString() + "°";
Accuracy.Text = data.HeadingAccuracy.ToString() + "°";
}
/// <summary>
/// Initializes a new instance of the <see cref="CompassValue"/> class.
/// </summary>
/// <param name="reading">The compass reading.</param>
public CompassValue(CompassReading reading)
: this(reading.Timestamp, reading.HeadingAccuracy, reading.MagneticHeading,
new Vector3(reading.MagnetometerReading), reading.TrueHeading) { }
private void ProcessCompass(CompassReading compassReading)
{
// Ignores the value if it's not a number or is not valid.
if (Double.IsNaN(compassReading.TrueHeading) || Double.IsNaN(compassReading.HeadingAccuracy))
{
return;
}
// Stores the new valid heading.
DeviceHeading = compassReading.TrueHeading;
DeviceHeadingAccuracy = compassReading.HeadingAccuracy;
}
/// <summary>
/// Formats current coordinates into JSON format
/// </summary>
/// <returns>Coordinates in JSON format</returns>
private string GetHeadingFormatted(CompassReading reading)
{
string result = String.Format("\"magneticHeading\":{0},\"headingAccuracy\":{1},\"trueHeading\":{2},\"timestamp\":{3}",
reading.MagneticHeading.ToString("0.0", CultureInfo.InvariantCulture),
reading.HeadingAccuracy.ToString("0.0", CultureInfo.InvariantCulture),
reading.TrueHeading.ToString("0.0", CultureInfo.InvariantCulture),
reading.Timestamp.UtcTicks.ToString());
result = "{" + result + "}";
return result;
}
