Project structure refactoring

src/common/coordinates.cpp

@@ -0,0 +1,52 @@
+#include "wgs84.h"
+#include "coordinates.h"
+
+#define MIN_LAT deg2rad(-90.0)
+#define MAX_LAT deg2rad(90.0)
+#define MIN_LON deg2rad(-180.0)
+#define MAX_LON deg2rad(180.0)
+
+qreal Coordinates::distanceTo(const Coordinates &c) const
+{
+	qreal dLat = deg2rad(c.lat() - _lat);
+	qreal dLon = deg2rad(c.lon() - _lon);
+	qreal a = pow(sin(dLat / 2.0), 2.0)
+	  + cos(deg2rad(_lat)) * cos(deg2rad(c.lat())) * pow(sin(dLon / 2.0), 2.0);
+
+	return (WGS84_RADIUS * (2.0 * atan2(sqrt(a), sqrt(1.0 - a))));
+}
+
+QDebug operator<<(QDebug dbg, const Coordinates &c)
+{
+	dbg.nospace() << "Coordinates(" << c.lon() << ", " << c.lat() << ")";
+	return dbg.space();
+}
+
+QPair<Coordinates, Coordinates> Coordinates::boundingRect(qreal distance) const
+{
+	qreal radDist = distance / WGS84_RADIUS;
+
+	qreal minLat = deg2rad(_lat) - radDist;
+	qreal maxLat = deg2rad(_lat) + radDist;
+
+	qreal minLon, maxLon;
+	if (minLat > MIN_LAT && maxLat < MAX_LAT) {
+		qreal deltaLon = asin(sin(radDist) / cos(_lat));
+		minLon = deg2rad(_lon) - deltaLon;
+		if (minLon < MIN_LON)
+			minLon += 2.0 * M_PI;
+		maxLon = deg2rad(_lon) + deltaLon;
+		if (maxLon > MAX_LON)
+			maxLon -= 2.0 * M_PI;
+	} else {
+		// a pole is within the distance
+		minLat = qMax(minLat, MIN_LAT);
+		maxLat = qMin(maxLat, MAX_LAT);
+		minLon = MIN_LON;
+		maxLon = MAX_LON;
+	}
+
+	return QPair<Coordinates, Coordinates>(Coordinates(rad2deg(qMin(minLon,
+	  maxLon)), rad2deg(qMin(minLat, maxLat))), Coordinates(rad2deg(qMax(minLon,
+	  maxLon)), rad2deg(qMax(minLat, maxLat))));
+}

src/common/coordinates.h

@@ -0,0 +1,48 @@
+#ifndef COORDINATES_H
+#define COORDINATES_H
+
+#include <cmath>
+#include <QPair>
+#include <QDebug>
+
+#ifndef M_PI
+	#define M_PI 3.14159265358979323846
+#endif // M_PI
+#define deg2rad(d) (((d)*M_PI)/180.0)
+#define rad2deg(d) (((d)*180.0)/M_PI)
+
+class Coordinates
+{
+public:
+	Coordinates() {_lon = NAN; _lat = NAN;}
+	Coordinates(const Coordinates &c) {_lon = c._lon; _lat = c._lat;}
+	Coordinates(qreal lon, qreal lat) {_lon = lon; _lat = lat;}
+
+	qreal &rlon() {return _lon;}
+	qreal &rlat() {return _lat;}
+	void setLon(qreal lon) {_lon = lon;}
+	void setLat(qreal lat) {_lat = lat;}
+	qreal lon() const {return _lon;}
+	qreal lat() const {return _lat;}
+
+	bool isNull() const
+	  {return std::isnan(_lon) && std::isnan(_lat);}
+	bool isValid() const
+	  {return (_lon >= -180.0 && _lon <= 180.0
+	    && _lat >= -90.0 && _lat <= 90.0);}
+
+	qreal distanceTo(const Coordinates &c) const;
+	QPair<Coordinates, Coordinates> boundingRect(qreal distance) const;
+
+private:
+	qreal _lat, _lon;
+};
+
+inline bool operator==(const Coordinates &c1, const Coordinates &c2)
+  {return (c1.lat() == c2.lat() && c1.lon() == c2.lon());}
+inline bool operator!=(const Coordinates &c1, const Coordinates &c2)
+  {return !(c1 == c2);}
+
+QDebug operator<<(QDebug dbg, const Coordinates &c);
+
+#endif // COORDINATES_H

src/common/range.cpp

@@ -0,0 +1,21 @@
+#include "range.h"
+
+void RangeF::resize(qreal size)
+{
+	qreal adj = (size/2 - this->size()/2);
+
+	_min -= adj;
+	_max += adj;
+}
+
+QDebug operator<<(QDebug dbg, const Range &range)
+{
+	dbg.nospace() << "Range(" << range.min() << ", " << range.max() << ")";
+	return dbg.space();
+}
+
+QDebug operator<<(QDebug dbg, const RangeF &range)
+{
+	dbg.nospace() << "RangeF(" << range.min() << ", " << range.max() << ")";
+	return dbg.space();
+}

src/common/range.h

@@ -0,0 +1,40 @@
+#ifndef RANGE_H
+#define RANGE_H
+
+#include <QtGlobal>
+#include <QDebug>
+
+class Range
+{
+public:
+	Range() {_min = 0; _max = 0;}
+	Range(int min, int max) {_min = min, _max = max;}
+
+	int min() const {return _min;}
+	int max() const {return _max;}
+	int size() const {return (_max - _min);}
+
+private:
+	int _min, _max;
+};
+
+class RangeF
+{
+public:
+	RangeF() {_min = 0; _max = 0;}
+	RangeF(qreal min, qreal max) {_min = min, _max = max;}
+
+	qreal min() const {return _min;}
+	qreal max() const {return _max;}
+	qreal size() const {return (_max - _min);}
+
+	void resize(qreal size);
+
+private:
+	qreal _min, _max;
+};
+
+QDebug operator<<(QDebug dbg, const Range &range);
+QDebug operator<<(QDebug dbg, const RangeF &range);
+
+#endif // RANGE_H

src/common/rectc.cpp

@@ -0,0 +1,63 @@
+#include "rectc.h"
+
+RectC RectC::operator|(const RectC &r) const
+{
+	if (isNull())
+		return r;
+	if (r.isNull())
+		return *this;
+
+	qreal l1 = _tl.lon();
+	qreal r1 = _tl.lon();
+	if (_br.lon() - _tl.lon() < 0)
+		l1 = _br.lon();
+	else
+		r1 = _br.lon();
+
+	qreal l2 = r._tl.lon();
+	qreal r2 = r._tl.lon();
+	if (r._br.lon() - r._tl.lon() < 0)
+		l2 = r._br.lon();
+	else
+		r2 = r._br.lon();
+
+	qreal t1 = _tl.lat();
+	qreal b1 = _tl.lat();
+	if (_br.lat() - _tl.lat() < 0)
+		t1 = _br.lat();
+	else
+		b1 = _br.lat();
+
+	qreal t2 = r._tl.lat();
+	qreal b2 = r._tl.lat();
+	if (r._br.lat() - r._tl.lat() < 0)
+		t2 = r._br.lat();
+	else
+		b2 = r._br.lat();
+
+	RectC tmp;
+	tmp._tl.setLon(qMin(l1, l2));
+	tmp._br.setLon(qMax(r1, r2));
+	tmp._tl.setLat(qMin(t1, t2));
+	tmp._br.setLat(qMax(b1, b2));
+
+	return tmp;
+}
+
+void RectC::unite(const Coordinates &c)
+{
+	if (c.lon() < _tl.lon())
+		_tl.setLon(c.lon());
+	if (c.lon() > _br.lon())
+		_br.setLon(c.lon());
+	if (c.lat() > _br.lat())
+		_br.setLat(c.lat());
+	if (c.lat() < _tl.lat())
+		_tl.setLat(c.lat());
+}
+
+QDebug operator<<(QDebug dbg, const RectC &rect)
+{
+	dbg.nospace() << "RectC(" << rect.topLeft() << ", " << rect.size() << ")";
+	return dbg.space();
+}

src/common/rectc.h

@@ -0,0 +1,42 @@
+#ifndef RECTC_H
+#define RECTC_H
+
+#include <QDebug>
+#include <QSizeF>
+#include "coordinates.h"
+
+class RectC
+{
+public:
+	RectC() {}
+	RectC(const Coordinates &topLeft, const Coordinates &bottomRight)
+	  : _tl(topLeft), _br(bottomRight) {}
+
+	bool isNull() const
+	  {return _tl.isNull() && _br.isNull();}
+	bool isValid() const
+	  {return (_tl.isValid() && _br.isValid() && _tl != _br);}
+
+	Coordinates topLeft() const {return _tl;}
+	Coordinates bottomRight() const {return _br;}
+
+	Coordinates center() const
+	  {return Coordinates((_tl.lon() + _br.lon()) / 2.0,
+	    (_tl.lat() + _br.lat()) / 2.0);}
+	qreal width() const {return  _br.lon() - _tl.lon();}
+	qreal height() const {return  _br.lat() - _tl.lat();}
+
+	QSizeF size() const {return QSizeF(width(), height());}
+
+	RectC operator|(const RectC &r) const;
+	RectC &operator|=(const RectC &r) {*this = *this | r; return *this;}
+
+	void unite(const Coordinates &c);
+
+private:
+	Coordinates _tl, _br;
+};
+
+QDebug operator<<(QDebug dbg, const RectC &rect);
+
+#endif // RECTC_H

src/common/staticassert.h

@@ -0,0 +1,11 @@
+#ifndef ASSERT_H
+#define ASSERT_H
+
+template<bool> struct CompileTimeAssert;
+template<> struct CompileTimeAssert <true> {};
+
+#define STATIC_ASSERT(e) \
+	(CompileTimeAssert <(e) != 0>())
+
+#endif // ASSERT_H
+

src/common/wgs84.h

@@ -0,0 +1,7 @@
+#ifndef WGS84_H
+#define WGS84_H
+
+#define WGS84_RADIUS     6378137.0
+#define WGS84_FLATTENING (1.0/298.257223563)
+
+#endif // WGS84_H