Азимут и угловая высота в WinRT

using System;
using Windows.Foundation;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Media.Media3D;

namespace WinRTTestApp
{
    public struct Vector3
    {
        // Конструкторы
        public Vector3(double x, double y, double z)
            : this()
        {
            X = x;
            Y = y;
            Z = z;
        }

        // Свойства
        public double X { private set; get; }
        public double Y { private set; get; }
        public double Z { private set; get; }

        public double LengthSquared
        {
            get { return X * X + Y * Y + Z * Z; }
        }

        public double Length
        {
            get { return Math.Sqrt(LengthSquared); }
        }

        public Vector3 Normalized
        {
            get
            {
                double length = this.Length;

                if (length != 0)
                {
                    return new Vector3(this.X / length,
                                       this.Y / length,
                                       this.Z / length);
                }
                return new Vector3();
            }
        }

        // Статичные свойства
        public static Vector3 UnitX
        {
            get { return new Vector3(1, 0, 0); }
        }

        public static Vector3 UnitY
        {
            get { return new Vector3(0, 1, 0); }
        }

        public static Vector3 UnitZ
        {
            get { return new Vector3(0, 0, 1); }
        }

        // Статичные методы
        public static Vector3 Cross(Vector3 v1, Vector3 v2)
        {
            return new Vector3(v1.Y * v2.Z - v1.Z * v2.Y,
                               v1.Z * v2.X - v1.X * v2.Z,
                               v1.X * v2.Y - v1.Y * v2.X);
        }

        public static double Dot(Vector3 v1, Vector3 v2)
        {
            return v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z;
        }

        public static double AngleBetween(Vector3 v1, Vector3 v2)
        {
            return 180 / Math.PI * Math.Acos(Vector3.Dot(v1, v2) /
                                                v1.Length * v2.Length);
        }

        public static Vector3 Transform(Vector3 v, Matrix3D m)
        {
            double x = m.M11 * v.X + m.M21 * v.Y + m.M31 * v.Z + m.OffsetX;
            double y = m.M12 * v.X + m.M22 * v.Y + m.M32 * v.Z + m.OffsetY;
            double z = m.M13 * v.X + m.M23 * v.Y + m.M33 * v.Z + m.OffsetZ;
            double w = m.M14 * v.X + m.M24 * v.Y + m.M34 * v.Z + m.M44;
            return new Vector3(x / w, y / w, z / w);
        }

        // Перегрузка операторов
        public static Vector3 operator +(Vector3 v1, Vector3 v2)
        {
            return new Vector3(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);
        }

        public static Vector3 operator -(Vector3 v1, Vector3 v2)
        {
            return new Vector3(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z);
        }

        public static Vector3 operator *(Vector3 v, double d)
        {
            return new Vector3(d * v.X, d * v.Y, d * v.Z);
        }

        public static Vector3 operator *(double d, Vector3 v)
        {
            return new Vector3(d * v.X, d * v.Y, d * v.Z);
        }

        public static Vector3 operator /(Vector3 v, double d)
        {
            return new Vector3(v.X / d, v.Y / d, v.Z / d);
        }

        public static Vector3 operator -(Vector3 v)
        {
            return new Vector3(-v.X, -v.Y, -v.Z);
        }

        // Переопределение ToString()
        public override string ToString()
        {
            return String.Format("({0} {1} {2})", X, Y, Z);
        }
    }
}

using System;
using Windows.UI.Xaml.Media.Media3D;

namespace WinRTTestApp
{
    public struct HorizontalCoordinate
    {
        public HorizontalCoordinate(double azimuth, double altitude, double tilt)
            : this()
        {
            this.Azimuth = azimuth;
            this.Altitude = altitude;
            this.Tilt = tilt;
        }

        public HorizontalCoordinate(double azimuth, double altitude)
            : this(azimuth, altitude, 0)
        {
        }

        // Северо-восток
        public double Azimuth { private set; get; }

        public double Altitude { private set; get; }

        public double Tilt { private set; get; }

        public static HorizontalCoordinate FromVector(Vector3 vector)
        {
            double altitude = 180 * Math.Asin(vector.Z) / Math.PI;
            double azimuth = 180 * Math.Atan2(vector.X, vector.Y) / Math.PI;

            return new HorizontalCoordinate(azimuth, altitude);
        }

        public static HorizontalCoordinate FromMotionMatrix(Matrix3D matrix)
        {
            // Инвертирование матрицы
            matrix.Invert();

            // Трансформация (0, 0, -1)
            Vector3 zAxisTransformed = Vector3.Transform(-Vector3.UnitZ, matrix);

            // Получение горизонтальной координаты
            HorizontalCoordinate horzCoord = FromVector(zAxisTransformed);

            // Получение теоретического значения HorizontalCoordinate,
            // для преобразования вектора +Y при вертикальном расположении устройства
            double yUprightAltitude = 0;
            double yUprightAzimuth = 0;

            if (horzCoord.Altitude > 0)
            {
                yUprightAltitude = 90 - horzCoord.Altitude;
                yUprightAzimuth = 180 + horzCoord.Azimuth;
            }
            else
            {
                yUprightAltitude = 90 + horzCoord.Altitude;
                yUprightAzimuth = horzCoord.Azimuth;
            }
            Vector3 yUprightVector = 
                new HorizontalCoordinate(yUprightAzimuth, yUprightAltitude).ToVector();

            // Определение реального преобразования вектора +Y
            Vector3 yAxisTransformed = Vector3.Transform(Vector3.UnitY, matrix);

            // Получение угла между вертикальным вектором +Y
            // и реальным преобразованным вектором +Y
            double dotProduct = Vector3.Dot(yUprightVector, yAxisTransformed);
            Vector3 crossProduct = Vector3.Cross(yUprightVector, yAxisTransformed);
            crossProduct = crossProduct.Normalized;

            // Иногда значение dotProduct слегка превышает 1,
            // что приводит к исключению при вычислении angleBetween, поэтому ...
            dotProduct = Math.Min(dotProduct, 1);
            double angleBetween = 180 * Vector3.Dot(zAxisTransformed, crossProduct) 
                                      * Math.Acos(dotProduct) / Math.PI;
            horzCoord.Tilt = angleBetween;

            return horzCoord;
        }

        public Vector3 ToVector()
        {
            double x = Math.Cos(Math.PI * this.Altitude / 180) * 
                       Math.Sin(Math.PI * this.Azimuth / 180);
            double y = Math.Cos(Math.PI * this.Altitude / 180) * 
                       Math.Cos(Math.PI * this.Azimuth / 180);
            double z = Math.Sin(Math.PI * this.Altitude / 180);

            return new Vector3((float)x, (float)y, (float)z);
        }

        public override string ToString()
        {
            return String.Format("Azi: {0} Alt: {1} Tilt: {2}", 
                                 this.Azimuth, this.Altitude, this.Tilt);
        }
    }
}

using System;
using Windows.Devices.Sensors;
using Windows.Graphics.Display;
using Windows.UI.Core;
using Windows.UI.Popups;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media.Animation;
using Windows.UI.Xaml.Media.Imaging;
using Windows.UI.Xaml.Media.Media3D;

namespace WinRTTestApp
{
    public sealed partial class MainPage : Page
    {
        // ...

        OrientationSensor orientationSensor = OrientationSensor.GetDefault();
        double pageWidth, pageHeight, maxDimension;
        int imageWidth, imageHeight;
        string title = "Сад земных наслаждений. И. Босх";
        double zoomInScale;
        double rotation;
        bool isZoomView;

        public MainPage()
        {
            this.InitializeComponent();
            DisplayProperties.AutoRotationPreferences = DisplayProperties.NativeOrientation;
            Loaded += OnMainPageLoaded;
            SizeChanged += OnMainPageSizeChanged;
        }

        // ...

        private async void OnMainPageLoaded(object sender, RoutedEventArgs e)
        {
            if (orientationSensor == null)
            {
                await new MessageDialog("Сенсор ориентации не поддерживается",
                                        "Ошибка").ShowAsync();

                progressBar.Visibility = Visibility.Collapsed;
                statusText.Visibility = Visibility.Collapsed;
            }
            else
            {
                bitmapImage.UriSource =
                  new Uri("http://upload.wikimedia.org/wikipedia/commons/6/62/The_Garden_of_Earthly_Delights_by_Bosch_High_Resolution_2.jpg");
            }
        }

        private void OnMainPageSizeChanged(object sender, SizeChangedEventArgs e)
        {
            // Сохранение размеров страницы
            pageWidth = this.ActualWidth;
            pageHeight = this.ActualHeight;
            maxDimension = Math.Max(pageWidth, pageHeight);

            // Инициализация некоторых свойств
            outlineBorder.Width = pageWidth;
            outlineBorder.Height = pageHeight;
            borderTransform.CenterX = pageWidth / 2;
            borderTransform.CenterY = pageHeight / 2;
        }

        private void OnBitmapImageDownloadProgress(object sender, 
            DownloadProgressEventArgs e)
        {
            progressBar.Value = e.Progress;
        }

        private async void OnBitmapImageFailed(object sender, ExceptionRoutedEventArgs e)
        {
            progressBar.Visibility = Visibility.Collapsed;
            statusText.Visibility = Visibility.Collapsed;

            await new MessageDialog("Невозможно загрузить картинку: " + e.ErrorMessage,
                                    "Ошибка").ShowAsync();
        }

        private void OnBitmapImageOpened(object sender, RoutedEventArgs e)
        {
            progressBar.Visibility = Visibility.Collapsed;
            statusText.Visibility = Visibility.Collapsed;

            // Сохранение размеров изображения
            imageWidth = bitmapImage.PixelWidth;
            imageHeight = bitmapImage.PixelHeight;
            titleText.Text = String.Format("{0} ({1}\x00D7{2})", title, imageWidth, imageHeight);

            // Инициализация преобразований
            zoomInScale = Math.Min(pageWidth / imageWidth, pageHeight / imageHeight);

            // Запуск OrientationSensor
            if (orientationSensor != null)
            {
                ProcessNewOrientationReading(orientationSensor.GetCurrentReading());
                orientationSensor.ReportInterval = orientationSensor.MinimumReportInterval;
                orientationSensor.ReadingChanged += OnOrientationSensorReadingChanged;
            }
        }

        private async void OnOrientationSensorReadingChanged(OrientationSensor sender, 
                                                     OrientationSensorReadingChangedEventArgs e)
        {
            await this.Dispatcher.RunAsync(
                CoreDispatcherPriority.Normal, () =>
                {
                    ProcessNewOrientationReading(e.Reading);
                });
        }

        // ...
    }
}