Direction indicator triange updating

[situare] / src / coordinates / scenecoordinate.cpp

diff --git a/src/coordinates/scenecoordinate.cpp b/src/coordinates/scenecoordinate.cpp
index 04388c2..c4b555e 100644 (file)
--- a/src/coordinates/scenecoordinate.cpp
+++ b/src/coordinates/scenecoordinate.cpp
@@ -19,10 +19,15 @@
     USA.
 */
 
+#include <cmath>
+
 #include <QDebug>
+#include <QLineF>
+#include <QPointF>
+#include <QVariant>
 
 #include "geocoordinate.h"
-#include "map/mapcommon.h"
+#include "map/osm.h"
 
 #include "scenecoordinate.h"
 
@@ -40,32 +45,32 @@ SceneCoordinate::SceneCoordinate(double x, double y) :
     qDebug() << __PRETTY_FUNCTION__;
 }
 
-SceneCoordinate::SceneCoordinate(GeoCoordinate &coordinate)
+SceneCoordinate::SceneCoordinate(const GeoCoordinate &coordinate)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
     convertFrom(coordinate);
 }
 
+qreal SceneCoordinate::azimuthTo(const SceneCoordinate &to) const
+{
+    QLineF line = QLineF(this->toPointF(), to.toPointF());
+    return -line.angle() + 90.0;
+}
+
 void SceneCoordinate::convertFrom(const GeoCoordinate &coordinate)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
-    Q_ASSERT(coordinate.longitude() > MAX_LONGITUDE);
-    Q_ASSERT(coordinate.longitude() < MIN_LONGITUDE);
-    Q_ASSERT(coordinate.latitude() > MAX_LATITUDE);
-    Q_ASSERT(coordinate.latitude() < MIN_LATITUDE);
-
     // calculate x & y positions in the map (0..1)
     double worldX = static_cast<double>((coordinate.longitude() + 180.0) / 360.0);
     double worldY = static_cast<double>((1.0 - log(tan(coordinate.latitude() * M_PI / 180.0) + 1.0
                                 / cos(coordinate.latitude() * M_PI / 180.0)) / M_PI) / 2.0);
 
-    setX(worldX * MAX_TILES_PER_SIDE * TILE_SIZE_X);
-    setY(worldY * MAX_TILES_PER_SIDE * TILE_SIZE_Y);
+    m_x = worldX * OSM_TILES_PER_SIDE * OSM_TILE_SIZE_X;
+    m_y = worldY * OSM_TILES_PER_SIDE * OSM_TILE_SIZE_Y;
 
-    Q_ASSERT((x() >= MAP_MIN_PIXEL_X) && (x() <= MAP_MAX_PIXEL_X));
-    Q_ASSERT((y() >= MAP_MIN_PIXEL_Y) && (y() <= MAP_MAX_PIXEL_Y));
+    normalize(m_x, OSM_MAP_MIN_PIXEL_X, OSM_MAP_MAX_PIXEL_X);
 }
 
 bool SceneCoordinate::isNull() const
@@ -78,18 +83,16 @@ bool SceneCoordinate::isNull() const
     return false;
 }
 
-double SceneCoordinate::x() const
+void SceneCoordinate::normalize(double &value, int min, int max)
 {
     qDebug() << __PRETTY_FUNCTION__;
+    Q_ASSERT_X(max >= min, "parameters", "max can't be smaller than min");
 
-    return m_x;
-}
-
-double SceneCoordinate::y() const
-{
-    qDebug() << __PRETTY_FUNCTION__;
+    while (int(value) < min)
+        value += max - min + 1;
 
-    return m_y;
+    while (int(value) > max)
+        value -= max - min + 1;
 }
 
 void SceneCoordinate::setX(double x)
@@ -106,9 +109,71 @@ void SceneCoordinate::setY(double y)
     m_y = y;
 }
 
+QPointF SceneCoordinate::toPointF() const
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    return QPointF(m_x, m_y);
+}
+
+double SceneCoordinate::x() const
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    return m_x;
+}
+
+double SceneCoordinate::y() const
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    return m_y;
+}
+
+SceneCoordinate::operator QVariant() const
+{
+    return QVariant::fromValue(*this);
+}
+
 QDebug operator<<(QDebug dbg, const SceneCoordinate &coordinate)
 {
     dbg.nospace() << "(" << coordinate.x() << ", " << coordinate.y() << ")";
 
     return dbg.space();
 }
+
+SceneCoordinate & SceneCoordinate::operator*=(double factor)
+{
+    m_x *= factor;
+    m_y *= factor;
+    return *this;
+}
+
+SceneCoordinate & SceneCoordinate::operator+=(const SceneCoordinate &coordinate)
+{
+    m_x += coordinate.x();
+    m_y += coordinate.y();
+    return *this;
+}
+
+SceneCoordinate & SceneCoordinate::operator-=(const SceneCoordinate &coordinate)
+{
+    m_x -= coordinate.x();
+    m_y -= coordinate.y();
+    return *this;
+}
+
+const SceneCoordinate operator* (double factor, const SceneCoordinate &coordinate)
+{
+    return SceneCoordinate(coordinate) *= factor;
+}
+
+const SceneCoordinate SceneCoordinate::operator+(const SceneCoordinate &other) const
+{
+  return SceneCoordinate(*this) += other;
+}
+
+const SceneCoordinate SceneCoordinate::operator-(const SceneCoordinate &other) const
+{
+  return SceneCoordinate(*this) -= other;
+}