Project structure refactoring

src/map/albersequal.cpp

@@ -0,0 +1,227 @@
+/*
+ * Based on libgeotrans with the following Source Code Disclaimer:
+
+1. The GEOTRANS source code ("the software") is provided free of charge by
+the National Imagery and Mapping Agency (NIMA) of the United States
+Department of Defense. Although NIMA makes no copyright claim under Title 17
+U.S.C., NIMA claims copyrights in the source code under other legal regimes.
+NIMA hereby grants to each user of the software a license to use and
+distribute the software, and develop derivative works.
+
+2. Warranty Disclaimer: The software was developed to meet only the internal
+requirements of the U.S. National Imagery and Mapping Agency. The software
+is provided "as is," and no warranty, express or implied, including but not
+limited to the implied warranties of merchantability and fitness for
+particular purpose or arising by statute or otherwise in law or from a
+course of dealing or usage in trade, is made by NIMA as to the accuracy and
+functioning of the software.
+
+3. NIMA and its personnel are not required to provide technical support or
+general assistance with respect to the software.
+
+4. Neither NIMA nor its personnel will be liable for any claims, losses, or
+damages arising from or connected with the use of the software. The user
+agrees to hold harmless the United States National Imagery and Mapping
+Agency. The user's sole and exclusive remedy is to stop using the software.
+
+5. NIMA requests that products developed using the software credit the
+source of the software with the following statement, "The product was
+developed using GEOTRANS, a product of the National Imagery and Mapping
+Agency and U.S. Army Engineering Research and Development Center."
+
+6. For any products developed using the software, NIMA requires a disclaimer
+that use of the software does not indicate endorsement or approval of the
+product by the Secretary of Defense or the National Imagery and Mapping
+Agency. Pursuant to the United States Code, 10 U.S.C. Sec. 2797, the name of
+the National Imagery and Mapping Agency, the initials "NIMA", the seal of
+the National Imagery and Mapping Agency, or any colorable imitation thereof
+shall not be used to imply approval, endorsement, or authorization of a
+product without prior written permission from United States Secretary of
+Defense.
+
+*/
+
+#include "albersequal.h"
+
+
+#ifndef M_PI_2
+	#define M_PI_2 1.57079632679489661923
+#endif // M_PI_2
+
+#define ONE_MINUS_SQR(x) (1.0 - (x) * (x))
+#define ALBERS_Q(slat, one_minus_sqr_es_sin, es_sin) \
+	(_one_minus_es2 * ((slat) / (one_minus_sqr_es_sin) - \
+	(1 / (_two_es)) * log((1 - (es_sin)) / (1 + (es_sin)))))
+#define ALBERS_M(clat, one_minus_sqr_es_sin) \
+	((clat) / sqrt(one_minus_sqr_es_sin))
+
+
+AlbersEqual::AlbersEqual(const Ellipsoid &ellipsoid, double standardParallel1,
+  double standardParallel2, double latitudeOrigin, double longitudeOrigin,
+  double falseEasting, double falseNorthing)
+{
+	double sin_lat, sin_lat1, sin_lat2, cos_lat1, cos_lat2;
+	double m1, m2, sqr_m1, sqr_m2;
+	double q0, q1, q2;
+	double es_sin, es_sin1, es_sin2;
+	double one_minus_sqr_es_sin1, one_minus_sqr_es_sin2;
+	double nq0;
+	double sp1, sp2;
+
+
+	_e = ellipsoid;
+	_latitudeOrigin = deg2rad(latitudeOrigin);
+	_longitudeOrigin = deg2rad(longitudeOrigin);
+	_falseEasting = falseEasting;
+	_falseNorthing = falseNorthing;
+
+	sp1 = deg2rad(standardParallel1);
+	sp2 = deg2rad(standardParallel2);
+
+	_es2 = 2 * _e.flattening() - _e.flattening() * _e.flattening();
+	_es = sqrt(_es2);
+	_one_minus_es2 = 1 - _es2;
+	_two_es = 2 * _es;
+
+	sin_lat = sin(_latitudeOrigin);
+	es_sin = _es * sin_lat;
+	q0 = ALBERS_Q(sin_lat, ONE_MINUS_SQR(es_sin), es_sin);
+
+	sin_lat1 = sin(sp1);
+	cos_lat1 = cos(sp1);
+	es_sin1 = _es * sin_lat1;
+	one_minus_sqr_es_sin1 = ONE_MINUS_SQR(es_sin1);
+	m1 = ALBERS_M(cos_lat1, one_minus_sqr_es_sin1);
+	q1 = ALBERS_Q(sin_lat1, one_minus_sqr_es_sin1, es_sin1);
+
+	sqr_m1 = m1 * m1;
+	if (fabs(sp1 - sp2) > 1.0e-10) {
+		sin_lat2 = sin(sp2);
+		cos_lat2 = cos(sp2);
+		es_sin2 = _es * sin_lat2;
+		one_minus_sqr_es_sin2 = ONE_MINUS_SQR(es_sin2);
+		m2 = ALBERS_M(cos_lat2, one_minus_sqr_es_sin2);
+		q2 = ALBERS_Q(sin_lat2, one_minus_sqr_es_sin2, es_sin2);
+		sqr_m2 = m2 * m2;
+		_n = (sqr_m1 - sqr_m2) / (q2 - q1);
+	} else
+		_n = sin_lat1;
+
+	_C = sqr_m1 + _n * q1;
+	_a_over_n = _e.radius() / _n;
+	nq0 = _n * q0;
+	_rho0 = (_C < nq0) ? 0 : _a_over_n * sqrt(_C - nq0);
+}
+
+QPointF AlbersEqual::ll2xy(const Coordinates &c) const
+{
+	double dlam;
+	double sin_lat;
+	double es_sin;
+	double q;
+	double rho;
+	double theta;
+	double nq;
+
+
+	dlam = deg2rad(c.lon()) - _longitudeOrigin;
+	if (dlam > M_PI)
+		dlam -= 2.0 * M_PI;
+	if (dlam < -M_PI)
+		dlam += 2.0 * M_PI;
+
+	sin_lat = sin(deg2rad(c.lat()));
+	es_sin = _es * sin_lat;
+	q = ALBERS_Q(sin_lat, ONE_MINUS_SQR(es_sin), es_sin);
+	nq = _n * q;
+	rho = (_C < nq) ? 0 : _a_over_n * sqrt(_C - nq);
+	theta = _n * dlam;
+
+	return QPointF(rho * sin(theta) + _falseEasting,
+	  _rho0 - rho * cos(theta) + _falseNorthing);
+}
+
+Coordinates AlbersEqual::xy2ll(const QPointF &p) const
+{
+	double dy, dx;
+	double rho0_minus_dy;
+	double q, qc, q_over_2;
+	double rho, rho_n;
+	double phi, delta_phi = 1.0;
+	double sin_phi;
+	double es_sin, one_minus_sqr_es_sin;
+	double theta = 0.0;
+	int count = 30;
+	double tolerance = 4.85e-10;
+	double lat, lon;
+
+
+	dy = p.y() - _falseNorthing;
+	dx = p.x() - _falseEasting;
+
+	rho0_minus_dy = _rho0 - dy;
+	rho = sqrt(dx * dx + rho0_minus_dy * rho0_minus_dy);
+
+	if (_n < 0) {
+		rho *= -1.0;
+		dx *= -1.0;
+		rho0_minus_dy *= -1.0;
+	}
+
+	if (rho != 0.0)
+		theta = atan2(dx, rho0_minus_dy);
+	rho_n = rho * _n;
+	q = (_C - (rho_n * rho_n) / (_e.radius() * _e.radius())) / _n;
+	qc = 1 - ((_one_minus_es2) / (_two_es)) * log((1.0 - _es) / (1.0 + _es));
+	if (fabs(fabs(qc) - fabs(q)) > 1.0e-6) {
+		q_over_2 = q / 2.0;
+		if (q_over_2 > 1.0)
+			lat = M_PI_2;
+		else if (q_over_2 < -1.0)
+			lat = -M_PI_2;
+		else {
+			phi = asin(q_over_2);
+			if (_es < 1.0e-10)
+				lat = phi;
+			else  {
+				while ((fabs(delta_phi) > tolerance) && count) {
+					sin_phi = sin(phi);
+					es_sin = _es * sin_phi;
+					one_minus_sqr_es_sin = ONE_MINUS_SQR(es_sin);
+					delta_phi = (one_minus_sqr_es_sin * one_minus_sqr_es_sin)
+					  / (2.0 * cos(phi)) * (q / (_one_minus_es2) - sin_phi
+					  / one_minus_sqr_es_sin + (log((1.0 - es_sin)
+					  / (1.0 + es_sin)) / (_two_es)));
+					phi += delta_phi;
+					count --;
+				}
+
+				lat = phi;
+			}
+
+			if (lat > M_PI_2)
+				lat = M_PI_2;
+			else if (lat < -M_PI_2)
+				lat = -M_PI_2;
+		}
+	} else {
+		if (q >= 0.0)
+			lat = M_PI_2;
+		else
+			lat = -M_PI_2;
+	}
+
+	lon = _longitudeOrigin + theta / _n;
+
+	if (lon > M_PI)
+		lon -= M_PI * 2;
+	if (lon < -M_PI)
+		lon += M_PI * 2;
+
+	if (lon > M_PI)
+		lon = M_PI;
+	else if (lon < -M_PI)
+		lon = -M_PI;
+
+	return Coordinates(rad2deg(lon), rad2deg(lat));
+}

src/map/albersequal.h

@@ -0,0 +1,35 @@
+#ifndef ALBERSEQUAL_H
+#define ALBERSEQUAL_H
+
+#include "ellipsoid.h"
+#include "projection.h"
+
+class AlbersEqual : public Projection
+{
+public:
+	AlbersEqual(const Ellipsoid &ellipsoid, double standardParallel1,
+	  double standardParallel2, double latitudeOrigin, double longitudeOrigin,
+	  double falseEasting, double falseNorthing);
+
+	virtual QPointF ll2xy(const Coordinates &c) const;
+	virtual Coordinates xy2ll(const QPointF &p) const;
+
+private:
+	Ellipsoid _e;
+
+	double _latitudeOrigin;
+	double _longitudeOrigin;
+	double _falseEasting;
+	double _falseNorthing;
+
+	double _rho0;
+	double _C;
+	double _n;
+	double _es;
+	double _es2;
+	double _a_over_n;
+	double _one_minus_es2;
+	double _two_es;
+};
+
+#endif // ALBERSEQUAL_H

src/map/atlas.cpp

@@ -0,0 +1,338 @@
+#include <QDir>
+#include <QtAlgorithms>
+#include <QPainter>
+#include "common/rectc.h"
+#include "tar.h"
+#include "atlas.h"
+
+
+#define ZOOM_THRESHOLD 0.9
+
+#define TL(m) ((m)->xy2pp((m)->bounds().topLeft()))
+#define BR(m) ((m)->xy2pp((m)->bounds().bottomRight()))
+
+static bool resCmp(const OfflineMap *m1, const OfflineMap *m2)
+{
+	qreal r1, r2;
+
+	r1 = m1->resolution(m1->bounds().center());
+	r2 = m2->resolution(m2->bounds().center());
+
+	return r1 > r2;
+}
+
+static bool xCmp(const OfflineMap *m1, const OfflineMap *m2)
+{
+	return TL(m1).x() < TL(m2).x();
+}
+
+static bool yCmp(const OfflineMap *m1, const OfflineMap *m2)
+{
+	return TL(m1).y() > TL(m2).y();
+}
+
+bool Atlas::isAtlas(Tar &tar, const QString &path)
+{
+	QFileInfo fi(path);
+	QByteArray ba;
+	QString suffix = fi.suffix().toLower();
+
+	if (suffix == "tar") {
+		if (!tar.load(path)) {
+			_errorString = "Error reading tar file";
+			return false;
+		}
+		QString tbaFileName = fi.completeBaseName() + ".tba";
+		ba = tar.file(tbaFileName);
+	} else if (suffix == "tba") {
+		QFile tbaFile(path);
+		if (!tbaFile.open(QIODevice::ReadOnly)) {
+			_errorString = QString("Error opening tba file: %1")
+			  .arg(tbaFile.errorString());
+			return false;
+		}
+		ba = tbaFile.readAll();
+	}
+
+	if (ba.startsWith("Atlas 1.0"))
+		return true;
+	else {
+		_errorString = "Missing or invalid tba file";
+		return false;
+	}
+}
+
+void Atlas::computeZooms()
+{
+	qSort(_maps.begin(), _maps.end(), resCmp);
+
+	_zooms.append(QPair<int, int>(0, _maps.count() - 1));
+	for (int i = 1; i < _maps.count(); i++) {
+		qreal last = _maps.at(i-1)->resolution(_maps.at(i)->bounds().center());
+		qreal cur = _maps.at(i)->resolution(_maps.at(i)->bounds().center());
+		if (cur < last * ZOOM_THRESHOLD) {
+			_zooms.last().second = i-1;
+			_zooms.append(QPair<int, int>(i, _maps.count() - 1));
+		}
+	}
+}
+
+void Atlas::computeBounds()
+{
+	QList<QPointF> offsets;
+
+	for (int i = 0; i < _maps.count(); i++)
+		offsets.append(QPointF());
+
+	for (int z = 0; z < _zooms.count(); z++) {
+		QList<OfflineMap*> m;
+		for (int i = _zooms.at(z).first; i <= _zooms.at(z).second; i++)
+			m.append(_maps.at(i));
+
+		qSort(m.begin(), m.end(), xCmp);
+		offsets[_maps.indexOf(m.first())].setX(0);
+		for (int i = 1; i < m.size(); i++) {
+			qreal w = round(m.first()->pp2xy(TL(m.at(i))).x());
+			offsets[_maps.indexOf(m.at(i))].setX(w);
+		}
+
+		qSort(m.begin(), m.end(), yCmp);
+		offsets[_maps.indexOf(m.first())].setY(0);
+		for (int i = 1; i < m.size(); i++) {
+			qreal h = round(m.first()->pp2xy(TL(m.at(i))).y());
+			offsets[_maps.indexOf(m.at(i))].setY(h);
+		}
+	}
+
+	for (int i = 0; i < _maps.count(); i++)
+		_bounds.append(QPair<QRectF, QRectF>(QRectF(TL(_maps.at(i)),
+		  BR(_maps.at(i))), QRectF(offsets.at(i), _maps.at(i)->bounds().size())));
+}
+
+Atlas::Atlas(const QString &fileName, QObject *parent) : Map(parent)
+{
+	Tar tar;
+	QFileInfo fi(fileName);
+
+	_valid = false;
+	_zoom = 0;
+	_name = fi.dir().dirName();
+	_ci = -1; _cz = -1;
+
+	if (!isAtlas(tar, fileName))
+		return;
+
+	QDir dir(fi.absolutePath());
+	QFileInfoList layers = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
+	for (int n = 0; n < layers.count(); n++) {
+		QDir zdir(layers.at(n).absoluteFilePath());
+		QFileInfoList maps = zdir.entryInfoList(QDir::Dirs
+		  | QDir::NoDotAndDotDot);
+		for (int i = 0; i < maps.count(); i++) {
+			QString mapFile = maps.at(i).absoluteFilePath() + "/"
+			  + maps.at(i).fileName() + ".map";
+
+			OfflineMap *map;
+			if (tar.isOpen())
+				map = new OfflineMap(mapFile, tar, this);
+			else
+				map = new OfflineMap(mapFile, this);
+
+			if (map->isValid())
+				_maps.append(map);
+			else {
+				_errorString = QString("Error loading map: %1: %2")
+				  .arg(mapFile, map->errorString());
+				return;
+			}
+		}
+	}
+	if (_maps.isEmpty()) {
+		_errorString = "No maps found in atlas";
+		return;
+	}
+
+	computeZooms();
+	computeBounds();
+
+	_valid = true;
+}
+
+Atlas::~Atlas()
+{
+	for (int i = 0; i < _maps.size(); i++)
+		delete _maps.at(i);
+}
+
+QRectF Atlas::bounds() const
+{
+	QSizeF s(0, 0);
+
+	for (int i = _zooms.at(_zoom).first; i <= _zooms.at(_zoom).second; i++) {
+		if (_bounds.at(i).second.right() > s.width())
+			s.setWidth(_bounds.at(i).second.right());
+		if (_bounds.at(i).second.bottom() > s.height())
+			s.setHeight(_bounds.at(i).second.bottom());
+	}
+
+	return QRectF(QPointF(0, 0), s);
+}
+
+qreal Atlas::resolution(const QPointF &p) const
+{
+	int idx = _zooms.at(_zoom).first;
+
+	for (int i = _zooms.at(_zoom).first; i <= _zooms.at(_zoom).second; i++) {
+		if (_bounds.at(i).second.contains(_maps.at(i)->xy2pp(p))) {
+			idx = i;
+			break;
+		}
+	}
+
+	return _maps.at(idx)->resolution(p);
+}
+
+qreal Atlas::zoom() const
+{
+	return _zoom;
+}
+
+qreal Atlas::zoomFit(const QSize &size, const RectC &br)
+{
+	_zoom = 0;
+
+	if (!br.isValid()) {
+		_zoom = _zooms.size() - 1;
+		return _zoom;
+	}
+
+	for (int z = 0; z < _zooms.count(); z++) {
+		for (int i = _zooms.at(z).first; i <= _zooms.at(z).second; i++) {
+			if (!_bounds.at(i).first.contains(_maps.at(i)->ll2pp(br.center())))
+				continue;
+
+			QRect sbr = QRectF(_maps.at(i)->ll2xy(br.topLeft()),
+			  _maps.at(i)->ll2xy(br.bottomRight())).toRect().normalized();
+
+			if (sbr.size().width() > size.width()
+			  || sbr.size().height() > size.height())
+				return _zoom;
+
+			_zoom = z;
+			break;
+		}
+	}
+
+	return _zoom;
+}
+
+qreal Atlas::zoomFit(qreal resolution, const Coordinates &c)
+{
+	_zoom = 0;
+
+	for (int z = 0; z < _zooms.count(); z++) {
+		for (int i = _zooms.at(z).first; i <= _zooms.at(z).second; i++) {
+			if (!_bounds.at(i).first.contains(_maps.at(i)->ll2pp(c)))
+				continue;
+
+			if (_maps.at(i)->resolution(_maps.at(i)->ll2xy(c)) < resolution)
+				return _zoom;
+
+			_zoom = z;
+			break;
+		}
+	}
+
+	return _zoom;
+}
+
+qreal Atlas::zoomIn()
+{
+	_zoom = qMin(_zoom + 1, _zooms.size() - 1);
+	return _zoom;
+}
+
+qreal Atlas::zoomOut()
+{
+	_zoom = qMax(_zoom - 1, 0);
+	return _zoom;
+}
+
+QPointF Atlas::ll2xy(const Coordinates &c)
+{
+	QPointF pp;
+
+	if (_cz != _zoom) {
+		_ci = -1;
+		_cz = _zoom;
+	}
+
+	if (_ci >= 0)
+		pp = _maps.at(_ci)->ll2pp(c);
+	if (_ci < 0 || !_bounds.at(_ci).first.contains(pp)) {
+		_ci = _zooms.at(_zoom).first;
+		for (int i = _zooms.at(_zoom).first; i <= _zooms.at(_zoom).second; i++) {
+			pp = _maps.at(i)->ll2pp(c);
+			if (_bounds.at(i).first.contains(pp)) {
+				_ci = i;
+				break;
+			}
+		}
+	}
+
+	QPointF p = _maps.at(_ci)->pp2xy(pp);
+	return p + _bounds.at(_ci).second.topLeft();
+}
+
+Coordinates Atlas::xy2ll(const QPointF &p)
+{
+	int idx = _zooms.at(_zoom).first;
+
+	for (int i = _zooms.at(_zoom).first; i <= _zooms.at(_zoom).second; i++) {
+		if (_bounds.at(i).second.contains(_maps.at(i)->xy2pp(p))) {
+			idx = i;
+			break;
+		}
+	}
+
+	QPointF p2 = p - _bounds.at(idx).second.topLeft();
+	return _maps.at(idx)->xy2ll(p2);
+}
+
+void Atlas::draw(QPainter *painter, const QRectF &rect)
+{
+	// All in one map
+	for (int i = _zooms.at(_zoom).first; i <= _zooms.at(_zoom).second; i++) {
+		if (_bounds.at(i).second.contains(rect)) {
+			draw(painter, rect, i);
+			return;
+		}
+	}
+
+	// Multiple maps
+	painter->fillRect(rect, _backgroundColor);
+	for (int i = _zooms.at(_zoom).first; i <= _zooms.at(_zoom).second; i++) {
+		QRectF ir = rect.intersected(_bounds.at(i).second);
+		if (!ir.isNull())
+			draw(painter, ir, i);
+	}
+}
+
+void Atlas::draw(QPainter *painter, const QRectF &rect, int mapIndex)
+{
+	OfflineMap *map = _maps.at(mapIndex);
+	const QPointF offset = _bounds.at(mapIndex).second.topLeft();
+	QRectF pr = QRectF(rect.topLeft() - offset, rect.size());
+
+	map->load();
+
+	painter->translate(offset);
+	map->draw(painter, pr);
+	painter->translate(-offset);
+}
+
+void Atlas::unload()
+{
+	for (int i = 0; i < _maps.count(); i++)
+		_maps.at(i)->unload();
+}

src/map/atlas.h

@@ -0,0 +1,56 @@
+#ifndef ATLAS_H
+#define ATLAS_H
+
+#include <QFileInfoList>
+#include "map/map.h"
+#include "offlinemap.h"
+
+
+class Atlas : public Map
+{
+	Q_OBJECT
+
+public:
+	Atlas(const QString &fileName, QObject *parent = 0);
+	~Atlas();
+
+	const QString &name() const {return _name;}
+
+	QRectF bounds() const;
+	qreal resolution(const QPointF &p) const;
+
+	qreal zoom() const;
+	qreal zoomFit(const QSize &size, const RectC &br);
+	qreal zoomFit(qreal resolution, const Coordinates &c);
+	qreal zoomIn();
+	qreal zoomOut();
+
+	QPointF ll2xy(const Coordinates &c);
+	Coordinates xy2ll(const QPointF &p);
+
+	void draw(QPainter *painter, const QRectF &rect);
+
+	void unload();
+
+	bool isValid() const {return _valid;}
+	const QString &errorString() const {return _errorString;}
+
+private:
+	void draw(QPainter *painter, const QRectF &rect, int mapIndex);
+	bool isAtlas(Tar &tar, const QString &path);
+	void computeZooms();
+	void computeBounds();
+
+	QString _name;
+	bool _valid;
+	QString _errorString;
+
+	QList<OfflineMap*> _maps;
+	QVector<QPair<int, int> > _zooms;
+	QVector<QPair<QRectF, QRectF> > _bounds;
+	int _zoom;
+
+	int _ci, _cz;
+};
+
+#endif // ATLAS_H

src/map/datum.cpp

@@ -0,0 +1,120 @@
+#include <cmath>
+#include <QFile>
+#include "common/wgs84.h"
+#include "datum.h"
+
+
+static QMap<QString, Datum> WGS84()
+{
+	QMap<QString, Datum> map;
+	map.insert("WGS 84", Datum(Ellipsoid(WGS84_RADIUS, WGS84_FLATTENING),
+	  0.0, 0.0, 0.0));
+	return map;
+}
+
+QMap<QString, Datum> Datum::_datums = WGS84();
+QString Datum::_errorString;
+int Datum::_errorLine = 0;
+
+Datum Datum::datum(const QString &name)
+{
+	QMap<QString, Datum>::const_iterator it = _datums.find(name);
+
+	if (it == _datums.end())
+		return Datum();
+
+	return it.value();
+}
+
+bool Datum::loadList(const QString &path)
+{
+	QFile file(path);
+	bool res;
+
+	if (!file.open(QFile::ReadOnly)) {
+		_errorString = qPrintable(file.errorString());
+		return false;
+	}
+
+	_errorLine = 1;
+	_errorString.clear();
+
+	while (!file.atEnd()) {
+		QByteArray line = file.readLine();
+		QList<QByteArray> list = line.split(',');
+		if (list.size() != 6) {
+			_errorString = "Format error";
+			return false;
+		}
+
+		int eid = list[2].trimmed().toInt(&res);
+		if (!res) {
+			_errorString = "Invalid ellipsoid id";
+			return false;
+		}
+		double dx = list[3].trimmed().toDouble(&res);
+		if (!res) {
+			_errorString = "Invalid dx";
+			return false;
+		}
+		double dy = list[4].trimmed().toDouble(&res);
+		if (!res) {
+			_errorString = "Invalid dy";
+			return false;
+		}
+		double dz = list[5].trimmed().toDouble(&res);
+		if (!res) {
+			_errorString = "Invalid dz";
+			return false;
+		}
+
+		Ellipsoid e = Ellipsoid::ellipsoid(eid);
+		if (e.isNull()) {
+			_errorString = "Unknown ellipsoid ID";
+			return false;
+		}
+
+		Datum d(e, dx, dy, dz);
+		_datums.insert(list[0].trimmed(), d);
+
+		_errorLine++;
+	}
+
+	return true;
+}
+
+// Abridged Molodensky transformation
+Coordinates Datum::toWGS84(const Coordinates &c) const
+{
+	if (_ellipsoid.radius() == WGS84_RADIUS
+	  && _ellipsoid.flattening() == WGS84_FLATTENING
+	  && _dx == 0.0 && _dy == 0.0 && _dz == 0.0)
+		return c;
+
+	double rlat = deg2rad(c.lat());
+	double rlon = deg2rad(c.lon());
+
+	double slat = sin(rlat);
+	double clat = cos(rlat);
+	double slon = sin(rlon);
+	double clon = cos(rlon);
+	double ssqlat = slat * slat;
+
+	double from_f = ellipsoid().flattening();
+	double df = WGS84_FLATTENING - from_f;
+	double from_a = ellipsoid().radius();
+	double da = WGS84_RADIUS - from_a;
+	double from_esq = ellipsoid().flattening()
+	  * (2.0 - ellipsoid().flattening());
+	double adb = 1.0 / (1.0 - from_f);
+	double rn = from_a / sqrt(1 - from_esq * ssqlat);
+	double rm = from_a * (1 - from_esq) / pow((1 - from_esq * ssqlat), 1.5);
+	double from_h = 0.0;
+
+	double dlat = (-dx() * slat * clon - dy() * slat * slon + dz() * clat + da
+	  * rn * from_esq * slat * clat / from_a + df * (rm * adb + rn / adb) * slat
+	  * clat) / (rm + from_h);
+	double dlon = (-dx() * slon + dy() * clon) / ((rn + from_h) * clat);
+
+	return Coordinates(c.lon() + rad2deg(dlon), c.lat() + rad2deg(dlat));
+}

src/map/datum.h

@@ -0,0 +1,40 @@
+#ifndef DATUM_H
+#define DATUM_H
+
+#include <QMap>
+#include "ellipsoid.h"
+#include "common/coordinates.h"
+
+class Datum
+{
+public:
+	Datum() : _ellipsoid(Ellipsoid()), _dx(0.0), _dy(0.0), _dz(0.0) {}
+	Datum(const Ellipsoid &ellipsoid, double dx, double dy, double dz)
+	  : _ellipsoid(ellipsoid), _dx(dx), _dy(dy), _dz(dz) {}
+
+	const Ellipsoid &ellipsoid() const {return _ellipsoid;}
+	double dx() const {return _dx;}
+	double dy() const {return _dy;}
+	double dz() const {return _dz;}
+
+	bool isNull() const
+	  {return (_ellipsoid.isNull() && _dx == 0.0 && _dy == 0.0 && _dz == 0.0);}
+
+	Coordinates toWGS84(const Coordinates &c) const;
+
+	static bool loadList(const QString &path);
+	static const QString &errorString() {return _errorString;}
+	static int errorLine() {return _errorLine;}
+
+	static Datum datum(const QString &name);
+
+private:
+	Ellipsoid _ellipsoid;
+	double _dx, _dy, _dz;
+
+	static QMap<QString, Datum> _datums;
+	static QString _errorString;
+	static int _errorLine;
+};
+
+#endif // DATUM_H

src/map/downloader.cpp

@@ -0,0 +1,134 @@
+#include <QFile>
+#include <QFileInfo>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+#include "config.h"
+#include "downloader.h"
+
+
+#if defined(Q_OS_LINUX)
+#define PLATFORM_STR "Linux"
+#elif defined(Q_OS_WIN32)
+#define PLATFORM_STR "Windows"
+#elif defined(Q_OS_MAC)
+#define PLATFORM_STR "OS X"
+#else
+#define PLATFORM_STR "Unknown"
+#endif
+
+#define USER_AGENT \
+	APP_NAME "/" APP_VERSION " (" PLATFORM_STR "; Qt " QT_VERSION_STR ")"
+
+#define ATTR_REDIRECT QNetworkRequest::RedirectionTargetAttribute
+#define ATTR_FILE     QNetworkRequest::User
+#define ATTR_ORIGIN   (QNetworkRequest::Attribute)(QNetworkRequest::User + 1)
+#define ATTR_LEVEL    (QNetworkRequest::Attribute)(QNetworkRequest::User + 2)
+
+#define MAX_REDIRECT_LEVEL 5
+
+
+Downloader::Downloader(QObject *parent) : QObject(parent)
+{
+	connect(&_manager, SIGNAL(finished(QNetworkReply*)),
+			SLOT(downloadFinished(QNetworkReply*)));
+}
+
+bool Downloader::doDownload(const Download &dl, const Redirect &redirect)
+{
+	QUrl url(dl.url());
+
+	if (_errorDownloads.contains(url))
+		return false;
+	if (_currentDownloads.contains(url))
+		return false;
+
+	QNetworkRequest request(url);
+	request.setAttribute(ATTR_FILE, QVariant(dl.file()));
+	if (!redirect.isNull()) {
+		request.setAttribute(ATTR_ORIGIN, QVariant(redirect.origin()));
+		request.setAttribute(ATTR_LEVEL, QVariant(redirect.level()));
+	}
+	request.setRawHeader("User-Agent", USER_AGENT);
+	QNetworkReply *reply = _manager.get(request);
+
+	_currentDownloads.insert(url, reply);
+
+	return true;
+}
+
+bool Downloader::saveToDisk(const QString &filename, QIODevice *data)
+{
+	QFile file(filename);
+
+	if (!file.open(QIODevice::WriteOnly)) {
+		qWarning("Error writing map tile: %s: %s\n",
+		  qPrintable(filename), qPrintable(file.errorString()));
+		return false;
+	}
+
+	file.write(data->readAll());
+	file.close();
+
+	return true;
+}
+
+void Downloader::downloadFinished(QNetworkReply *reply)
+{
+	QUrl url = reply->request().url();
+
+	if (reply->error()) {
+		QUrl origin = reply->request().attribute(ATTR_ORIGIN).toUrl();
+		if (origin.isEmpty()) {
+			_errorDownloads.insert(url);
+			qWarning("Error downloading map tile: %s: %s\n",
+			  url.toEncoded().constData(), qPrintable(reply->errorString()));
+		} else {
+			_errorDownloads.insert(origin);
+			qWarning("Error downloading map tile: %s -> %s: %s\n",
+			  origin.toEncoded().constData(), url.toEncoded().constData(),
+			  qPrintable(reply->errorString()));
+		}
+	} else {
+		QUrl location = reply->attribute(ATTR_REDIRECT).toUrl();
+		QString filename = reply->request().attribute(ATTR_FILE)
+		  .toString();
+
+		if (!location.isEmpty()) {
+			QUrl origin = reply->request().attribute(ATTR_ORIGIN).toUrl();
+			int level = reply->request().attribute(ATTR_LEVEL).toInt();
+
+			if (location == url) {
+				_errorDownloads.insert(url);
+				qWarning("Error downloading map tile: %s: "
+				  "redirect loop\n", url.toEncoded().constData());
+			} else if (level >= MAX_REDIRECT_LEVEL) {
+				_errorDownloads.insert(origin);
+				qWarning("Error downloading map tile: %s: "
+				  "redirect level limit reached\n",
+				  origin.toEncoded().constData());
+			} else {
+				Redirect redirect(origin.isEmpty() ? url : origin, level + 1);
+				Download dl(location, filename);
+				doDownload(dl, redirect);
+			}
+		} else
+			if (!saveToDisk(filename, reply))
+				_errorDownloads.insert(url);
+	}
+
+	_currentDownloads.remove(url);
+	reply->deleteLater();
+
+	if (_currentDownloads.isEmpty())
+		emit finished();
+}
+
+bool Downloader::get(const QList<Download> &list)
+{
+	bool finishEmitted = false;
+
+	for (int i = 0; i < list.count(); i++)
+		finishEmitted |= doDownload(list.at(i));
+
+	return finishEmitted;
+}

src/map/downloader.h

@@ -0,0 +1,68 @@
+#ifndef DOWNLOADER_H
+#define DOWNLOADER_H
+
+#include <QNetworkAccessManager>
+#include <QUrl>
+#include <QList>
+#include <QMap>
+#include <QSet>
+
+
+class QNetworkReply;
+
+class Download
+{
+public:
+	Download(const QUrl &url, const QString &file)
+		{_url = url; _file = file;}
+	const QUrl& url() const {return _url;}
+	const QString& file() const {return _file;}
+
+private:
+	QUrl _url;
+	QString _file;
+};
+
+
+class Downloader : public QObject
+{
+	Q_OBJECT
+
+public:
+	Downloader(QObject *parent = 0);
+
+	bool get(const QList<Download> &list);
+
+signals:
+	void finished();
+
+private slots:
+	void downloadFinished(QNetworkReply *reply);
+
+private:
+	class Redirect
+	{
+	public:
+		Redirect() : _level(0) {}
+		Redirect(const QUrl &origin, int level) :
+		  _origin(origin), _level(level) {}
+
+		const QUrl &origin() const {return _origin;}
+		int level() const {return _level;}
+
+		bool isNull() const {return (_level == 0);}
+
+	private:
+		QUrl _origin;
+		int _level;
+	};
+
+	bool doDownload(const Download &dl, const Redirect &redirect = Redirect());
+	bool saveToDisk(const QString &filename, QIODevice *data);
+
+	QNetworkAccessManager _manager;
+	QMap<QUrl, QNetworkReply *> _currentDownloads;
+	QSet<QUrl> _errorDownloads;
+};
+
+#endif // DOWNLOADER_H

src/map/ellipsoid.cpp

@@ -0,0 +1,62 @@
+#include <QFile>
+#include "ellipsoid.h"
+
+QMap<int, Ellipsoid> Ellipsoid::_ellipsoids;
+QString Ellipsoid::_errorString;
+int Ellipsoid::_errorLine = 0;
+
+Ellipsoid Ellipsoid::ellipsoid(int id)
+{
+	QMap<int, Ellipsoid>::const_iterator it = _ellipsoids.find(id);
+
+	if (it == _ellipsoids.end())
+		return Ellipsoid();
+
+	return it.value();
+}
+
+bool Ellipsoid::loadList(const QString &path)
+{
+	QFile file(path);
+	bool res;
+
+	if (!file.open(QFile::ReadOnly)) {
+		_errorString = qPrintable(file.errorString());
+		return false;
+	}
+
+	_errorLine = 1;
+	_errorString.clear();
+
+	while (!file.atEnd()) {
+		QByteArray line = file.readLine();
+		QList<QByteArray> list = line.split(',');
+		if (list.size() != 4) {
+			_errorString = "Format error";
+			return false;
+		}
+
+		int id = list[0].trimmed().toInt(&res);
+		if (!res) {
+			_errorString = "Invalid ellipsoid id";
+			return false;
+		}
+		double radius = list[2].trimmed().toDouble(&res);
+		if (!res) {
+			_errorString = "Invalid ellipsoid radius";
+			return false;
+		}
+		double flattening = list[3].trimmed().toDouble(&res);
+		if (!res) {
+			_errorString = "Invalid ellipsoid flattening";
+			return false;
+		}
+
+		Ellipsoid e(radius, 1.0/flattening);
+		_ellipsoids.insert(id, e);
+
+		_errorLine++;
+	}
+
+	return true;
+}

src/map/ellipsoid.h

@@ -0,0 +1,34 @@
+#ifndef ELLIPSOID_H
+#define ELLIPSOID_H
+
+#include <QString>
+#include <QMap>
+
+class Ellipsoid
+{
+public:
+	Ellipsoid() : _radius(0.0), _flattening(0.0) {}
+	Ellipsoid(double radius, double flattening)
+	  : _radius(radius), _flattening(flattening) {}
+
+	double radius() const {return _radius;}
+	double flattening() const {return _flattening;}
+
+	bool isNull() const {return (_radius == 0.0 && _flattening == 0.0);}
+
+	static bool loadList(const QString &path);
+	static const QString &errorString() {return _errorString;}
+	static int errorLine() {return _errorLine;}
+
+	static Ellipsoid ellipsoid(int id);
+
+private:
+	double _radius;
+	double _flattening;
+
+	static QMap<int, Ellipsoid> _ellipsoids;
+	static QString _errorString;
+	static int _errorLine;
+};
+
+#endif // ELLIPSOID_H

src/map/emptymap.cpp

@@ -0,0 +1,85 @@
+#include <QtGlobal>
+#include <QPainter>
+#include "common/coordinates.h"
+#include "common/rectc.h"
+#include "common/wgs84.h"
+#include "mercator.h"
+#include "misc.h"
+#include "emptymap.h"
+
+
+#define SCALE_MIN 0.5
+#define SCALE_MAX 1.0E-6
+
+EmptyMap::EmptyMap(QObject *parent) : Map(parent)
+{
+	_scale = SCALE_MAX;
+}
+
+QRectF EmptyMap::bounds() const
+{
+	return scaled(QRectF(QPointF(-180, -180), QSizeF(360, 360)), 1.0/_scale);
+}
+
+qreal EmptyMap::zoomFit(const QSize &size, const RectC &br)
+{
+	if (!br.isValid())
+		_scale = SCALE_MAX;
+	else {
+		QRectF tbr(Mercator().ll2xy(br.topLeft()),
+		  Mercator().ll2xy(br.bottomRight()));
+		QPointF sc(tbr.width() / size.width(), tbr.height() / size.height());
+		_scale = qMax(sc.x(), sc.y());
+	}
+
+	_scale = qMax(_scale, SCALE_MAX);
+	_scale = qMin(_scale, SCALE_MIN);
+
+	return _scale;
+}
+
+qreal EmptyMap::zoomFit(qreal resolution, const Coordinates &c)
+{
+	_scale = (360.0 * resolution) / (WGS84_RADIUS * 2 * M_PI
+	  * cos(deg2rad(c.lat())));
+
+	_scale = qMax(_scale, SCALE_MAX);
+	_scale = qMin(_scale, SCALE_MIN);
+
+	return _scale;
+}
+
+qreal EmptyMap::resolution(const QPointF &p) const
+{
+	return (WGS84_RADIUS * 2 * M_PI * _scale / 360.0
+	  * cos(2.0 * atan(exp(deg2rad(-p.y() * _scale))) - M_PI/2));
+}
+
+qreal EmptyMap::zoomIn()
+{
+	_scale = qMax(_scale / 2.0, SCALE_MAX);
+	return _scale;
+}
+
+qreal EmptyMap::zoomOut()
+{
+	_scale = qMin(_scale * 2.0, SCALE_MIN);
+	return _scale;
+}
+
+void EmptyMap::draw(QPainter *painter, const QRectF &rect)
+{
+	painter->fillRect(rect, _backgroundColor);
+}
+
+QPointF EmptyMap::ll2xy(const Coordinates &c)
+{
+	QPointF m = Mercator().ll2xy(c);
+	return QPointF(m.x() / _scale, m.y() / -_scale);
+}
+
+Coordinates EmptyMap::xy2ll(const QPointF &p)
+{
+	QPointF m(p.x() * _scale, -p.y() * _scale);
+	return Mercator().xy2ll(m);
+}

src/map/emptymap.h

@@ -0,0 +1,34 @@
+#ifndef EMPTYMAP_H
+#define EMPTYMAP_H
+
+#include "map/map.h"
+
+class EmptyMap : public Map
+{
+	Q_OBJECT
+
+public:
+	EmptyMap(QObject *parent = 0);
+
+	const QString &name() const {return _name;}
+
+	QRectF bounds() const;
+	qreal resolution(const QPointF &p) const;
+
+	qreal zoom() const {return _scale;}
+	qreal zoomFit(const QSize &size, const RectC &br);
+	qreal zoomFit(qreal resolution, const Coordinates &c);
+	qreal zoomIn();
+	qreal zoomOut();
+
+	QPointF ll2xy(const Coordinates &c);
+	Coordinates xy2ll(const QPointF &p);
+
+	void draw(QPainter *painter, const QRectF &rect);
+
+private:
+	QString _name;
+	qreal _scale;
+};
+
+#endif // EMPTYMAP_H

src/map/lambertazimuthal.cpp

@@ -0,0 +1,193 @@
+/*
+ * Based on libgeotrans with the following Source Code Disclaimer:
+
+1. The GEOTRANS source code ("the software") is provided free of charge by
+the National Imagery and Mapping Agency (NIMA) of the United States
+Department of Defense. Although NIMA makes no copyright claim under Title 17
+U.S.C., NIMA claims copyrights in the source code under other legal regimes.
+NIMA hereby grants to each user of the software a license to use and
+distribute the software, and develop derivative works.
+
+2. Warranty Disclaimer: The software was developed to meet only the internal
+requirements of the U.S. National Imagery and Mapping Agency. The software
+is provided "as is," and no warranty, express or implied, including but not
+limited to the implied warranties of merchantability and fitness for
+particular purpose or arising by statute or otherwise in law or from a
+course of dealing or usage in trade, is made by NIMA as to the accuracy and
+functioning of the software.
+
+3. NIMA and its personnel are not required to provide technical support or
+general assistance with respect to the software.
+
+4. Neither NIMA nor its personnel will be liable for any claims, losses, or
+damages arising from or connected with the use of the software. The user
+agrees to hold harmless the United States National Imagery and Mapping
+Agency. The user's sole and exclusive remedy is to stop using the software.
+
+5. NIMA requests that products developed using the software credit the
+source of the software with the following statement, "The product was
+developed using GEOTRANS, a product of the National Imagery and Mapping
+Agency and U.S. Army Engineering Research and Development Center."
+
+6. For any products developed using the software, NIMA requires a disclaimer
+that use of the software does not indicate endorsement or approval of the
+product by the Secretary of Defense or the National Imagery and Mapping
+Agency. Pursuant to the United States Code, 10 U.S.C. Sec. 2797, the name of
+the National Imagery and Mapping Agency, the initials "NIMA", the seal of
+the National Imagery and Mapping Agency, or any colorable imitation thereof
+shall not be used to imply approval, endorsement, or authorization of a
+product without prior written permission from United States Secretary of
+Defense.
+
+*/
+
+#include "lambertazimuthal.h"
+
+
+#ifndef M_PI_2
+	#define M_PI_2 1.57079632679489661923
+#endif // M_PI_2
+
+LambertAzimuthal::LambertAzimuthal(const Ellipsoid &ellipsoid,
+  double latitudeOrigin, double longitudeOrigin, double falseEasting,
+  double falseNorthing)
+{
+	double es2, es4, es6;
+
+	_e = ellipsoid;
+	es2 = 2 * _e.flattening() - _e.flattening() * _e.flattening();
+
+	es4 = es2 * es2;
+	es6 = es4 * es2;
+	_ra = _e.radius() * (1.0 - es2 / 6.0 - 17.0 * es4 / 360.0 - 67.0 * es6
+	  / 3024.0);
+	_latOrigin = deg2rad(latitudeOrigin);
+	_sinLatOrigin = sin(_latOrigin);
+	_cosLatOrigin = cos(_latOrigin);
+	_absLatOrigin = fabs(_latOrigin);
+	_lonOrigin = deg2rad(longitudeOrigin);
+	if (_lonOrigin > M_PI)
+		_lonOrigin -= 2.0 * M_PI;
+
+	_falseNorthing = falseNorthing;
+	_falseEasting = falseEasting;
+}
+
+QPointF LambertAzimuthal::ll2xy(const Coordinates &c) const
+{
+	double dlam;
+	double k_prime;
+	double cd;
+	double rlat = deg2rad(c.lat());
+	double slat = sin(rlat);
+	double clat = cos(rlat);
+	double cos_c;
+	double sin_dlam, cos_dlam;
+	double Ra_kprime;
+	double Ra_PI_OVER_2_Lat;
+	QPointF p;
+
+
+	dlam = deg2rad(c.lon()) - _lonOrigin;
+	if (dlam > M_PI)
+		dlam -= 2.0 * M_PI;
+	if (dlam < -M_PI)
+		dlam += 2.0 * M_PI;
+
+	sin_dlam = sin(dlam);
+	cos_dlam = cos(dlam);
+	if (fabs(_absLatOrigin - M_PI_2) < 1.0e-10) {
+		if (_latOrigin >= 0.0) {
+			Ra_PI_OVER_2_Lat = _ra * (M_PI_2 - rlat);
+			p.rx() = Ra_PI_OVER_2_Lat * sin_dlam + _falseEasting;
+			p.ry() = -1.0 * (Ra_PI_OVER_2_Lat * cos_dlam) + _falseNorthing;
+		} else {
+			Ra_PI_OVER_2_Lat = _ra * (M_PI_2 + rlat);
+			p.rx() = Ra_PI_OVER_2_Lat * sin_dlam + _falseEasting;
+			p.ry() = Ra_PI_OVER_2_Lat * cos_dlam + _falseNorthing;
+		}
+	} else if (_absLatOrigin <= 1.0e-10) {
+		cos_c = clat * cos_dlam;
+		if (fabs(fabs(cos_c) - 1.0) < 1.0e-14) {
+			if (cos_c >= 0.0) {
+				p.rx() = _falseEasting;
+				p.ry() = _falseNorthing;
+			} else
+				return QPointF(NAN, NAN);
+		} else {
+			cd = acos(cos_c);
+			k_prime = cd / sin(cd);
+			Ra_kprime = _ra * k_prime;
+			p.rx() = Ra_kprime * clat * sin_dlam + _falseEasting;
+			p.ry() = Ra_kprime * slat + _falseNorthing;
+		}
+	} else {
+		cos_c = (_sinLatOrigin * slat) + (_cosLatOrigin * clat * cos_dlam);
+		if (fabs(fabs(cos_c) - 1.0) < 1.0e-14) {
+			if (cos_c >= 0.0) {
+				p.rx() = _falseEasting;
+				p.ry() = _falseNorthing;
+			} else
+				return QPointF(NAN, NAN);
+		} else {
+			cd = acos(cos_c);
+			k_prime = cd / sin(cd);
+			Ra_kprime = _ra * k_prime;
+			p.rx() = Ra_kprime * clat * sin_dlam + _falseEasting;
+			p.ry() = Ra_kprime * (_cosLatOrigin * slat - _sinLatOrigin * clat
+			  * cos_dlam) + _falseNorthing;
+		}
+	}
+
+	return p;
+}
+
+Coordinates LambertAzimuthal::xy2ll(const QPointF &p) const
+{
+	double dx, dy;
+	double rho;
+	double cd;
+	double sin_c, cos_c, dy_sinc;
+	double lat, lon;
+
+
+	dy = p.y() - _falseNorthing;
+	dx = p.x() - _falseEasting;
+	rho = sqrt(dx * dx + dy * dy);
+	if (fabs(rho) <= 1.0e-10) {
+		lat = _latOrigin;
+		lon = _lonOrigin;
+	} else {
+		cd = rho / _ra;
+		sin_c = sin(cd);
+		cos_c = cos(cd);
+		dy_sinc = dy * sin_c;
+		lat = asin((cos_c * _sinLatOrigin) + ((dy_sinc * _cosLatOrigin) / rho));
+		if (fabs(_absLatOrigin - M_PI_2) < 1.0e-10) {
+			if (_latOrigin >= 0.0)
+				lon = _lonOrigin + atan2(dx, -dy);
+			else
+				lon = _lonOrigin + atan2(dx, dy);
+			}
+		else
+			lon = _lonOrigin + atan2((dx * sin_c), ((rho * _cosLatOrigin
+			  * cos_c) - (dy_sinc * _sinLatOrigin)));
+	}
+
+	if (lat > M_PI_2)
+		lat = M_PI_2;
+	else if (lat < -M_PI_2)
+		lat = -M_PI_2;
+
+	if (lon > M_PI)
+		lon -= 2.0 * M_PI;
+	if (lon < -M_PI)
+		lon += 2.0 * M_PI;
+
+	if (lon > M_PI)
+		lon = M_PI;
+	else if (lon < -M_PI)
+		lon = -M_PI;
+
+	return Coordinates(rad2deg(lon), rad2deg(lat));
+}

src/map/lambertazimuthal.h

@@ -0,0 +1,30 @@
+#ifndef LAMBERTAZIMUTHAL_H
+#define LAMBERTAZIMUTHAL_H
+
+#include "ellipsoid.h"
+#include "projection.h"
+
+class LambertAzimuthal : public Projection
+{
+public:
+	LambertAzimuthal(const Ellipsoid &ellipsoid, double latitudeOrigin,
+	  double longitudeOrigin, double falseEasting, double falseNorthing);
+
+	virtual QPointF ll2xy(const Coordinates &c) const;
+	virtual Coordinates xy2ll(const QPointF &p) const;
+
+private:
+	Ellipsoid _e;
+
+	double _ra;
+	double _sinLatOrigin;
+	double _cosLatOrigin;
+	double _absLatOrigin;
+
+	double _latOrigin;
+	double _lonOrigin;
+	double _falseNorthing;
+	double _falseEasting;
+};
+
+#endif // LAMBERTAZIMUTHAL_H

src/map/lambertconic.cpp

@@ -0,0 +1,80 @@
+#include <cmath>
+#include "lambertconic.h"
+
+#ifndef M_PI_2
+	#define M_PI_2 1.57079632679489661923
+#endif // M_PI_2
+#ifndef M_PI_4
+	#define M_PI_4 0.78539816339744830962
+#endif // M_PI_4
+
+static double q(const Ellipsoid &el, double b)
+{
+	double e = sqrt(el.flattening() * (2. - el.flattening()));
+	double esb = e * sin(b);
+	return log(tan(M_PI_4 + b / 2.) * pow((1. - esb) / (1. + esb), e / 2.));
+}
+
+static double iq(const Ellipsoid &el, double q)
+{
+	double e = sqrt(el.flattening() * (2. - el.flattening()));
+	double b0 = 0.;
+	double b = 2. * atan(exp(q)) - M_PI_2;
+
+	do {
+		b0 = b;
+		double esb = e * sin(b);
+		b = 2. * atan(exp(q) * pow((1. - esb) / (1. + esb), -e / 2.)) - M_PI_2;
+	} while (fabs(b - b0) > 1e-10);
+
+	return b;
+}
+
+static double nradius(const Ellipsoid &el, double phi)
+{
+	double sin_phi = sin(phi);
+	return (el.radius() / sqrt(1. - (el.flattening() * (2. - el.flattening()))
+	  * sin_phi * sin_phi));
+}
+
+LambertConic::LambertConic(const Ellipsoid &ellipsoid, double standardParallel1,
+  double standardParallel2, double latitudeOrigin, double longitudeOrigin,
+  double scale, double falseEasting, double falseNorthing) : _e(ellipsoid)
+{
+	_cm = deg2rad(longitudeOrigin);
+	_fe = falseEasting;
+	_fn = falseNorthing;
+
+	double sp1 = deg2rad(standardParallel1);
+	double sp2 = deg2rad(standardParallel2);
+
+	double N1 = nradius(_e, sp1);
+	double N2 = nradius(_e, sp2);
+
+	_q0 = q(_e, deg2rad(latitudeOrigin));
+	double q1 = q(_e, sp1);
+	double q2 = q(_e, sp2);
+
+	_n = log((N1 * cos(sp1)) / (N2 * cos(sp2))) / (q2 - q1);
+	double R1 = N1 * cos(sp1) / _n;
+	_R0 = scale * R1 * exp(_n * (q1 - _q0));
+}
+
+QPointF LambertConic::ll2xy(const Coordinates &c) const
+{
+	double dl = _n * (deg2rad(c.lon()) - _cm);
+	double R = _R0 * exp(_n * (_q0 - q(_e, deg2rad(c.lat()))));
+
+	return QPointF(_fe + R * sin(dl), _fn + _R0 - R * cos(dl));
+}
+
+Coordinates LambertConic::xy2ll(const QPointF &p) const
+{
+	double dl = atan((p.x() - _fe) / (_fn + _R0 - p.y()));
+	double dx = p.x() - _fe;
+	double dy = p.y() - _fn - _R0;
+	double R = sqrt(dx * dx + dy * dy);
+	double q = _q0 - log(fabs(R / _R0)) / _n;
+
+	return Coordinates(rad2deg(_cm + dl / _n), rad2deg(iq(_e, q)));
+}

src/map/lambertconic.h

@@ -0,0 +1,29 @@
+#ifndef LAMBERTCONIC_H
+#define LAMBERTCONIC_H
+
+#include "ellipsoid.h"
+#include "projection.h"
+
+class LambertConic : public Projection
+{
+public:
+	LambertConic(const Ellipsoid &ellipsoid, double standardParallel1,
+	  double standardParallel2, double latitudeOrigin, double longitudeOrigin,
+	  double scale, double falseEasting, double falseNorthing);
+
+	virtual QPointF ll2xy(const Coordinates &c) const;
+	virtual Coordinates xy2ll(const QPointF &p) const;
+
+private:
+	Ellipsoid _e;
+
+	double _cm;
+	double _fe;
+	double _fn;
+
+	double _q0;
+	double _R0;
+	double _n;
+};
+
+#endif // LAMBERTCONIC_H

src/map/latlon.h

@@ -0,0 +1,15 @@
+#ifndef LATLON_H
+#define LATLON_H
+
+#include "projection.h"
+
+class LatLon : public Projection
+{
+public:
+	virtual QPointF ll2xy(const Coordinates &c) const
+	  {return QPointF(c.lon(), c.lat());}
+	virtual Coordinates xy2ll(const QPointF &p) const
+	  {return Coordinates(p.x(), p.y());}
+};
+
+#endif // LATLON_H

src/map/map.h

@@ -0,0 +1,50 @@
+#ifndef MAP_H
+#define MAP_H
+
+#include <QObject>
+#include <QString>
+#include <QRectF>
+#include <QColor>
+
+class QPainter;
+class Coordinates;
+class RectC;
+
+class Map : public QObject
+{
+	Q_OBJECT
+
+public:
+	Map(QObject *parent = 0) : QObject(parent) {_backgroundColor = Qt::white;}
+
+	virtual const QString &name() const = 0;
+
+	virtual QRectF bounds() const = 0;
+	virtual qreal resolution(const QPointF &p) const = 0;
+
+	virtual qreal zoom() const = 0;
+	virtual qreal zoomFit(const QSize &size, const RectC &br) = 0;
+	virtual qreal zoomFit(qreal resolution, const Coordinates &c) = 0;
+	virtual qreal zoomIn() = 0;
+	virtual qreal zoomOut() = 0;
+
+	virtual QPointF ll2xy(const Coordinates &c) = 0;
+	virtual Coordinates xy2ll(const QPointF &p) = 0;
+
+	virtual void draw(QPainter *painter, const QRectF &rect) = 0;
+
+	virtual void setBlockingMode(bool block) {Q_UNUSED(block);}
+	virtual void clearCache() {}
+	virtual void load() {}
+	virtual void unload() {}
+
+	void setBackgroundColor(const QColor &color) {_backgroundColor = color;}
+
+signals:
+	void loaded();
+
+protected:
+	QColor _backgroundColor;
+};
+
+#endif // MAP_H

src/map/maplist.cpp

@@ -0,0 +1,150 @@
+#include <QFileInfo>
+#include <QDir>
+#include "common/range.h"
+#include "atlas.h"
+#include "offlinemap.h"
+#include "onlinemap.h"
+#include "maplist.h"
+
+
+#define ZOOM_MAX 18
+#define ZOOM_MIN  2
+
+Map *MapList::loadListEntry(const QByteArray &line)
+{
+	int max;
+
+	QList<QByteArray> list = line.split('\t');
+	if (list.size() < 2)
+		return 0;
+
+	QByteArray ba1 = list.at(0).trimmed();
+	QByteArray ba2 = list.at(1).trimmed();
+	if (ba1.isEmpty() || ba2.isEmpty())
+		return 0;
+
+	if (list.size() == 3) {
+		bool ok;
+		max = QString(list.at(2).trimmed()).toInt(&ok);
+		if (!ok)
+			return 0;
+	} else
+		max = ZOOM_MAX;
+
+	return new OnlineMap(QString::fromUtf8(ba1.data(), ba1.size()),
+	  QString::fromLatin1(ba2.data(), ba2.size()), Range(ZOOM_MIN, max), this);
+}
+
+bool MapList::loadList(const QString &path)
+{
+	QFile file(path);
+	QList<Map*> maps;
+
+	if (!file.open(QFile::ReadOnly | QFile::Text)) {
+		_errorString = file.errorString();
+		return false;
+	}
+
+	int ln = 0;
+	while (!file.atEnd()) {
+		ln++;
+		QByteArray line = file.readLine();
+		Map *map = loadListEntry(line);
+
+		if (map)
+			maps.append(map);
+		else {
+			for (int i = 0; i < maps.count(); i++)
+				delete maps.at(i);
+			_errorString = QString("Invalid map list entry on line %1.")
+			  .arg(QString::number(ln));
+			return false;
+		}
+	}
+
+	_maps += maps;
+
+	return true;
+}
+
+bool MapList::loadMap(const QString &path)
+{
+	OfflineMap *map = new OfflineMap(path, this);
+	if (map->isValid()) {
+		_maps.append(map);
+		return true;
+	} else {
+		_errorString = map->errorString();
+		delete map;
+		return false;
+	}
+}
+
+bool MapList::loadTba(const QString &path)
+{
+	Atlas *atlas = new Atlas(path, this);
+	if (atlas->isValid()) {
+		_maps.append(atlas);
+		return true;
+	} else {
+		_errorString = atlas->errorString();
+		delete atlas;
+		return false;
+	}
+}
+
+bool MapList::loadTar(const QString &path)
+{
+	Atlas *atlas = new Atlas(path, this);
+	if (atlas->isValid()) {
+		_maps.append(atlas);
+		return true;
+	} else {
+		_errorString = atlas->errorString();
+		delete atlas;
+		OfflineMap *map = new OfflineMap(path, this);
+		if (map->isValid()) {
+			_maps.append(map);
+			return true;
+		} else {
+			qWarning("%s: %s", qPrintable(path), qPrintable(_errorString));
+			qWarning("%s: %s", qPrintable(path),
+			  qPrintable(map->errorString()));
+			_errorString = "Not a map/atlas file";
+			delete map;
+			return false;
+		}
+	}
+}
+
+bool MapList::loadFile(const QString &path)
+{
+	QFileInfo fi(path);
+	QString suffix = fi.suffix().toLower();
+
+	if (suffix == "txt")
+		return loadList(path);
+	else if (suffix == "map")
+		return loadMap(path);
+	else if (suffix == "tba")
+		return loadTba(path);
+	else if (suffix == "tar")
+		return loadTar(path);
+	else {
+		_errorString = "Not a map/atlas file";
+		return false;
+	}
+}
+
+QString MapList::formats()
+{
+	return tr("Map files (*.map *.tba *.tar)") + ";;"
+	  + tr("URL list files (*.txt)");
+}
+
+QStringList MapList::filter()
+{
+	QStringList filter;
+	filter << "*.map" << "*.tba" << "*.tar" << "*.txt";
+	return filter;
+}

src/map/maplist.h

@@ -0,0 +1,35 @@
+#ifndef MAPLIST_H
+#define MAPLIST_H
+
+#include <QObject>
+#include <QString>
+#include "map.h"
+
+class MapList : public QObject
+{
+	Q_OBJECT
+
+public:
+	MapList(QObject *parent = 0) : QObject(parent) {}
+
+	bool loadFile(const QString &path);
+
+	const QList<Map*> &maps() const {return _maps;}
+	const QString &errorString() const {return _errorString;}
+
+	static QString formats();
+	static QStringList filter();
+
+private:
+	Map *loadListEntry(const QByteArray &line);
+
+	bool loadList(const QString &path);
+	bool loadMap(const QString &path);
+	bool loadTba(const QString &path);
+	bool loadTar(const QString &path);
+
+	QList<Map*> _maps;
+	QString _errorString;
+};
+
+#endif // MAPLIST_H

src/map/matrix.cpp

@@ -0,0 +1,130 @@
+#include "matrix.h"
+
+
+#define abs(x) ((x)<0 ? -(x) : (x))
+
+Matrix::~Matrix()
+{
+	if (isNull())
+		return;
+
+	delete[] _m;
+}
+
+Matrix::Matrix(size_t h, size_t w)
+{
+	_h = h; _w = w;
+
+	if (isNull())
+		_m = 0;
+	else
+		_m = new double[_h * _w];
+}
+
+Matrix::Matrix(const Matrix& M)
+{
+	_h = M._h; _w = M._w;
+
+	if (isNull())
+		_m = 0;
+	else
+		_m = new double[_h * _w];
+
+	for (size_t i = 0; i < _h; i++)
+		for (size_t j = 0; j < _w; j++)
+			m(i,j) = M.m(i,j);
+}
+
+Matrix &Matrix::operator=(const Matrix &M)
+{
+	if (_h != M._h || _w != M._w) {
+		if (!isNull())
+			delete[] _m;
+
+		_h = M._h; _w = M._w;
+		if (isNull())
+			_m = 0;
+		else
+			_m = new double[_h * _w];
+	}
+
+	for (size_t i = 0; i < _h; i++)
+		for (size_t j = 0; j < _w; j++)
+			m(i,j) = M.m(i,j);
+
+	return *this;
+}
+
+bool Matrix::eliminate(double epsilon)
+{
+	size_t i, j, k, maxrow;
+	double temp;
+
+
+	for (i = 0; i < _h; i++) {
+		maxrow = i;
+		for (j = i+1; j < _h; j++)
+			if (abs(m(j, i)) > abs(m(maxrow, i)))
+				maxrow = j;
+		for (j = 0; j < _w; j++) {
+			temp = m(i, j);
+			m(i, j) = m(maxrow, j);
+			m(maxrow, j) = temp;
+		}
+		if (abs(m(i, i)) <= epsilon)
+			return false;
+		for (j = i+1; j<_h; j++) {
+			temp = m(j, i) / m(i, i);
+			for (k = i; k < _w; k++)
+				m(j, k) -= m(i, k) * temp;
+		}
+	}
+	for (i = _h-1; i < i+1; i--) {
+		temp  = m(i, i);
+		for (j = 0; j < i; j++)
+			for (k = _w-1; k >= i; k--)
+				m(j, k) -=  m(i, k) * m(j, i) / temp;
+		m(i, i) /= temp;
+		for (j = _h; j < _w; j++)
+			m(i, j) /= temp;
+	}
+
+	return true;
+}
+
+Matrix Matrix::augemented(const Matrix &M) const
+{
+	if (_h != M._h)
+		return Matrix();
+
+	Matrix A(_h, _w + M._w);
+
+	for (size_t i = 0; i < _h; i++)
+		for (size_t j = 0; j < _w; j++)
+			A.m(i, j) = m(i, j);
+
+	for (size_t i = 0; i < _h; i++)
+		for (size_t j = _w; j < A._w; j++)
+			A.m(i, j) = M.m(i, j-_w);
+
+	return A;
+}
+
+void Matrix::zeroize()
+{
+	for (size_t i = 0; i < _h * _w; i++)
+		_m[i] = 0;
+}
+
+QDebug operator<<(QDebug dbg, const Matrix &matrix)
+{
+	dbg.nospace() << "Matrix(" << endl;
+	for (size_t i = 0; i < matrix.h(); i++) {
+		for (size_t j = 0; j < matrix.w(); j++)
+			dbg << "\t" << matrix.m(i, j);
+		dbg << endl;
+	}
+	dbg << ")";
+
+	return dbg.space();
+}

src/map/matrix.h

@@ -0,0 +1,36 @@
+#ifndef MATRIX_H
+#define MATRIX_H
+
+#include <cstddef>
+#include <cfloat>
+#include <QDebug>
+
+class Matrix {
+public:
+	Matrix() {_h = 0; _w = 0; _m = 0;}
+	Matrix(size_t h, size_t w);
+	Matrix(const Matrix& M);
+	~Matrix();
+
+	Matrix &operator=(const Matrix &M);
+
+	size_t h() const {return _h;}
+	size_t w() const {return _w;}
+	double &m(size_t i, size_t j) {return _m[_w * i + j];}
+	double const &m(size_t i, size_t j) const {return _m[_w * i + j];}
+
+	bool isNull() const {return (_h == 0 || _w == 0);}
+
+	void zeroize();
+	bool eliminate(double epsilon = DBL_EPSILON);
+	Matrix augemented(const Matrix &M) const;
+
+private:
+	double *_m;
+	size_t _h;
+	size_t _w;
+};
+
+QDebug operator<<(QDebug dbg, const Matrix &matrix);
+
+#endif // MATRIX_H

src/map/mercator.cpp

@@ -0,0 +1,12 @@
+#include <cmath>
+#include "mercator.h"
+
+QPointF Mercator::ll2xy(const Coordinates &c) const
+{
+	return QPointF(c.lon(), rad2deg(log(tan(M_PI/4.0 + deg2rad(c.lat())/2.0))));
+}
+
+Coordinates Mercator::xy2ll(const QPointF &p) const
+{
+	return Coordinates(p.x(), rad2deg(2 * atan(exp(deg2rad(p.y()))) - M_PI/2));
+}

src/map/mercator.h

@@ -0,0 +1,13 @@
+#ifndef MERCATOR_H
+#define MERCATOR_H
+
+#include "projection.h"
+
+class Mercator : public Projection
+{
+public:
+	virtual QPointF ll2xy(const Coordinates &c) const;
+	virtual Coordinates xy2ll(const QPointF &p) const;
+};
+
+#endif // MERCATOR_H

src/map/misc.h

@@ -0,0 +1,7 @@
+#include <QRectF>
+
+inline QRectF scaled(const QRectF &rect, qreal factor)
+{
+	return QRectF(QPointF(rect.left() * factor, rect.top() * factor),
+	  QSizeF(rect.width() * factor, rect.height() * factor));
+}

src/map/offlinemap.cpp

@@ -0,0 +1,729 @@
+#include <QtGlobal>
+#include <QPainter>
+#include <QFileInfo>
+#include <QMap>
+#include <QDir>
+#include <QBuffer>
+#include <QImage>
+#include <QImageReader>
+#include <QPixmapCache>
+#include "common/coordinates.h"
+#include "common/rectc.h"
+#include "datum.h"
+#include "utm.h"
+#include "matrix.h"
+#include "ozf.h"
+#include "offlinemap.h"
+
+
+int OfflineMap::parse(QIODevice &device, QList<ReferencePoint> &points,
+  QString &projection, Projection::Setup &setup, QString &datum)
+{
+	bool res;
+	int ln = 1;
+
+	while (!device.atEnd()) {
+		QByteArray line = device.readLine();
+
+		if (ln == 1) {
+			if (!line.trimmed().startsWith("OziExplorer Map Data File"))
+				return ln;
+		} else if (ln == 2)
+			_name = line.trimmed();
+		else if (ln == 3)
+			_imgPath = line.trimmed();
+		else if (ln == 5)
+			datum = line.split(',').at(0).trimmed();
+		else {
+			QList<QByteArray> list = line.split(',');
+			QString key(list.at(0).trimmed());
+			bool ll = true; bool pp = true;
+
+			if (key.startsWith("Point") && list.count() == 17
+			  && !list.at(2).trimmed().isEmpty()) {
+				int x = list.at(2).trimmed().toInt(&res);
+				if (!res)
+					return ln;
+				int y = list.at(3).trimmed().toInt(&res);
+				if (!res)
+					return ln;
+
+				int latd = list.at(6).trimmed().toInt(&res);
+				if (!res)
+					ll = false;
+				qreal latm = list.at(7).trimmed().toFloat(&res);
+				if (!res)
+					ll = false;
+				int lond = list.at(9).trimmed().toInt(&res);
+				if (!res)
+					ll = false;
+				qreal lonm = list.at(10).trimmed().toFloat(&res);
+				if (!res)
+					ll = false;
+				if (ll && list.at(8).trimmed() == "S") {
+					latd = -latd;
+					latm = -latm;
+				}
+				if (ll && list.at(11).trimmed() == "W") {
+					lond = -lond;
+					lonm = -lonm;
+				}
+
+				setup.zone = list.at(13).trimmed().toInt(&res);
+				if (!res)
+					setup.zone = 0;
+				qreal ppx = list.at(14).trimmed().toFloat(&res);
+				if (!res)
+					pp = false;
+				qreal ppy = list.at(15).trimmed().toFloat(&res);
+				if (!res)
+					pp = false;
+				if (list.at(16).trimmed() == "S")
+					setup.zone = -setup.zone;
+
+				ReferencePoint p;
+				p.xy = QPoint(x, y);
+				if (ll) {
+					p.ll = Coordinates(lond + lonm/60.0, latd + latm/60.0);
+					if (p.ll.isValid())
+						points.append(p);
+					else
+						return ln;
+				} else if (pp) {
+					p.pp = QPointF(ppx, ppy);
+					points.append(p);
+				} else
+					return ln;
+			} else if (key == "IWH") {
+				if (list.count() < 4)
+					return ln;
+				int w = list.at(2).trimmed().toInt(&res);
+				if (!res)
+					return ln;
+				int h = list.at(3).trimmed().toInt(&res);
+				if (!res)
+					return ln;
+				_size = QSize(w, h);
+			} else if (key == "Map Projection") {
+				if (list.count() < 2)
+					return ln;
+				projection = list.at(1);
+			} else if (key == "Projection Setup") {
+				if (list.count() < 8)
+					return ln;
+				setup.latitudeOrigin = list.at(1).trimmed().toFloat(&res);
+				if (!res)
+					setup.latitudeOrigin = 0;
+				setup.longitudeOrigin = list.at(2).trimmed().toFloat(&res);
+				if (!res)
+					setup.longitudeOrigin = 0;
+				setup.scale = list.at(3).trimmed().toFloat(&res);
+				if (!res)
+					setup.scale = 1.0;
+				setup.falseEasting = list.at(4).trimmed().toFloat(&res);
+				if (!res)
+					setup.falseEasting = 0;
+				setup.falseNorthing = list.at(5).trimmed().toFloat(&res);
+				if (!res)
+					setup.falseNorthing = 0;
+				setup.standardParallel1 = list.at(6).trimmed().toFloat(&res);
+				if (!res)
+					setup.standardParallel1 = 0;
+				setup.standardParallel2 = list.at(7).trimmed().toFloat(&res);
+				if (!res)
+					setup.standardParallel2 = 0;
+			}
+		}
+
+		ln++;
+	}
+
+	if (!setup.zone && !points.first().ll.isNull())
+		setup.zone = UTM::zone(points.first().ll);
+
+	return 0;
+}
+
+bool OfflineMap::parseMapFile(QIODevice &device, QList<ReferencePoint> &points,
+  QString &projection, Projection::Setup &setup, QString &datum)
+{
+	int el;
+
+	if (!device.open(QIODevice::ReadOnly)) {
+		_errorString = QString("Error opening map file: %1")
+		  .arg(device.errorString());
+		return false;
+	}
+
+	if ((el = parse(device, points, projection, setup, datum))) {
+		_errorString = QString("Map file parse error on line %1").arg(el);
+		return false;
+	}
+
+	return true;
+}
+
+bool OfflineMap::createProjection(const QString &datum,
+  const QString &projection, const Projection::Setup &setup,
+  QList<ReferencePoint> &points)
+{
+	if (points.count() < 2) {
+		_errorString = "Insufficient number of reference points";
+		return false;
+	}
+
+	Datum d = Datum::datum(datum);
+	if (d.isNull()) {
+		_errorString = QString("%1: Unknown datum").arg(datum);
+		return false;
+	}
+
+	_projection = Projection::projection(projection, d.ellipsoid(), setup);
+	if (!_projection) {
+		_errorString = Projection::errorString();
+		return false;
+	}
+
+	for (int i = 0; i < points.size(); i++) {
+		if (points.at(i).ll.isNull())
+			points[i].ll = d.toWGS84(_projection->xy2ll(points.at(i).pp));
+		else
+			points[i].ll = d.toWGS84(points[i].ll);
+	}
+
+	return true;
+}
+
+bool OfflineMap::simpleTransformation(const QList<ReferencePoint> &points)
+{
+	if (points.at(0).xy.x() == points.at(1).xy.x()
+	  || points.at(0).xy.y() == points.at(1).xy.y()) {
+		_errorString = "Invalid reference points tuple";
+		return false;
+	}
+
+	QPointF p0(_projection->ll2xy(points.at(0).ll));
+	QPointF p1(_projection->ll2xy(points.at(1).ll));
+
+	qreal dX, dY, lat0, lon0;
+	dX = (p0.x() - p1.x()) / (points.at(0).xy.x() - points.at(1).xy.x());
+	dY = (p1.y() - p0.y()) / (points.at(1).xy.y() - points.at(0).xy.y());
+	lat0 = p0.y() - points.at(0).xy.y() * dY;
+	lon0 = p1.x() - points.at(1).xy.x() * dX;
+
+	_transform = QTransform(1.0/dX, 0, 0, 1.0/dY, -lon0/dX, -lat0/dY);
+	_inverted = _transform.inverted();
+
+	return true;
+}
+
+bool OfflineMap::affineTransformation(const QList<ReferencePoint> &points)
+{
+	Matrix c(3, 2);
+	c.zeroize();
+	for (size_t i = 0; i < c.h(); i++) {
+		for (size_t j = 0; j < c.w(); j++) {
+			for (int k = 0; k < points.size(); k++) {
+				double f[3], t[2];
+				QPointF p = _projection->ll2xy(points.at(k).ll);
+
+				f[0] = p.x();
+				f[1] = p.y();
+				f[2] = 1.0;
+				t[0] = points.at(k).xy.x();
+				t[1] = points.at(k).xy.y();
+				c.m(i,j) += f[i] * t[j];
+			}
+		}
+	}
+
+	Matrix Q(3, 3);
+	Q.zeroize();
+	for (int qi = 0; qi < points.size(); qi++) {
+		double v[3];
+		QPointF p = _projection->ll2xy(points.at(qi).ll);
+
+		v[0] = p.x();
+		v[1] = p.y();
+		v[2] = 1.0;
+		for (size_t i = 0; i < Q.h(); i++)
+			for (size_t j = 0; j < Q.w(); j++)
+				Q.m(i,j) += v[i] * v[j];
+	}
+
+	Matrix M = Q.augemented(c);
+	if (!M.eliminate()) {
+		_errorString = "Singular transformation matrix";
+		return false;
+	}
+
+	_transform = QTransform(M.m(0,3), M.m(0,4), M.m(1,3), M.m(1,4), M.m(2,3),
+	  M.m(2,4));
+	_inverted = _transform.inverted();
+
+	return true;
+}
+
+bool OfflineMap::computeTransformation(const QList<ReferencePoint> &points)
+{
+	Q_ASSERT(points.size() >= 2);
+
+	if (points.size() == 2)
+		return simpleTransformation(points);
+	else
+		return affineTransformation(points);
+}
+
+bool OfflineMap::computeResolution(QList<ReferencePoint> &points)
+{
+	Q_ASSERT(points.count() >= 2);
+
+	int maxLon = 0, minLon = 0, maxLat = 0, minLat = 0;
+	qreal dLon, pLon, dLat, pLat;
+
+	for (int i = 1; i < points.size(); i++) {
+		if (points.at(i).ll.lon() < points.at(minLon).ll.lon())
+			minLon = i;
+		if (points.at(i).ll.lon() > points.at(maxLon).ll.lon())
+			maxLon = i;
+		if (points.at(i).ll.lat() < points.at(minLat).ll.lon())
+			minLat = i;
+		if (points.at(i).ll.lat() > points.at(maxLat).ll.lon())
+			maxLat = i;
+	}
+
+	dLon = points.at(minLon).ll.distanceTo(points.at(maxLon).ll);
+	pLon = QLineF(points.at(minLon).xy, points.at(maxLon).xy).length();
+	dLat = points.at(minLat).ll.distanceTo(points.at(maxLat).ll);
+	pLat = QLineF(points.at(minLat).xy, points.at(maxLat).xy).length();
+
+	_resolution = (dLon/pLon + dLat/pLat) / 2.0;
+
+	return true;
+}
+
+bool OfflineMap::getImageInfo(const QString &path)
+{
+	QFileInfo ii(_imgPath);
+
+	if (ii.isRelative())
+		ii.setFile(path + "/" + _imgPath);
+
+	if (!ii.exists()) {
+		int last = _imgPath.lastIndexOf('\\');
+		if (last >= 0 && last < _imgPath.length() - 1) {
+			QStringRef fn(&_imgPath, last + 1, _imgPath.length() - last - 1);
+			ii.setFile(path + "/" + fn.toString());
+		}
+	}
+
+	if (ii.exists())
+		_imgPath = ii.absoluteFilePath();
+	else {
+		_errorString = QString("%1: No such image file").arg(_imgPath);
+		return false;
+	}
+
+	if (OZF::isOZF(_imgPath)) {
+		if (!_ozf.load(_imgPath)) {
+			_errorString = QString("%1: Error loading OZF file")
+			  .arg(QFileInfo(_imgPath).fileName());
+			return false;
+		}
+	} else {
+		QImageReader img(_imgPath);
+		_size = img.size();
+		if (!_size.isValid()) {
+			_errorString = QString("%1: Error reading map image")
+			  .arg(QFileInfo(_imgPath).fileName());
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool OfflineMap::getTileInfo(const QStringList &tiles, const QString &path)
+{
+	QRegExp rx("_[0-9]+_[0-9]+\\.");
+	for (int i = 0; i < tiles.size(); i++) {
+		if (tiles.at(i).contains(rx)) {
+			_tileName = QString(tiles.at(i)).replace(rx, "_%1_%2.");
+
+			if (path.isNull()) {
+				QByteArray ba = _tar.file(tiles.at(i));
+				QBuffer buffer(&ba);
+				_tileSize = QImageReader(&buffer).size();
+			} else {
+				_tileName = path + "/" + _tileName;
+				_tileSize = QImageReader(path + "/" + tiles.at(i)).size();
+			}
+			if (!_tileSize.isValid()) {
+				_errorString = QString("Error retrieving tile size: "
+				  "%1: Invalid image").arg(QFileInfo(tiles.at(i)).fileName());
+				return false;
+			}
+
+			return true;
+		}
+	}
+
+	_errorString = "Invalid/missing tile set";
+	return false;
+}
+
+bool OfflineMap::totalSizeSet()
+{
+	if (!_size.isValid()) {
+		_errorString = "Missing total image size (IWH)";
+		return false;
+	} else
+		return true;
+}
+
+OfflineMap::OfflineMap(const QString &fileName, QObject *parent)
+  : Map(parent)
+{
+	QList<ReferencePoint> points;
+	QString proj, datum;
+	Projection::Setup setup;
+	QFileInfo fi(fileName);
+	QString suffix = fi.suffix().toLower();
+
+
+	_valid = false;
+	_img = 0;
+	_projection = 0;
+	_resolution = 0.0;
+	_zoom = 0;
+	_scale = QPointF(1.0, 1.0);
+
+	if (suffix == "tar") {
+		if (!_tar.load(fileName)) {
+			_errorString = "Error reading tar file";
+			return;
+		}
+
+		QString mapFileName = fi.completeBaseName() + ".map";
+		QByteArray ba = _tar.file(mapFileName);
+		if (ba.isNull()) {
+			_errorString = "Map file not found";
+			return;
+		}
+		QBuffer mapFile(&ba);
+		if (!parseMapFile(mapFile, points, proj, setup, datum))
+			return;
+	} else if (suffix =="map") {
+		QFile mapFile(fileName);
+		if (!parseMapFile(mapFile, points, proj, setup, datum))
+			return;
+	} else {
+		_errorString = "Not a map file";
+		return;
+	}
+
+	if (!createProjection(datum, proj, setup, points))
+		return;
+	if (!computeTransformation(points))
+		return;
+	computeResolution(points);
+
+	if (_tar.isOpen()) {
+		if (!totalSizeSet())
+			return;
+		if (!getTileInfo(_tar.files()))
+			return;
+		_imgPath = QString();
+	} else {
+		QDir set(fi.absolutePath() + "/" + "set");
+		if (set.exists()) {
+			if (!totalSizeSet())
+				return;
+			if (!getTileInfo(set.entryList(), set.absolutePath()))
+				return;
+			_imgPath = QString();
+		} else {
+			if (!getImageInfo(fi.absolutePath()))
+				return;
+		}
+	}
+
+	_valid = true;
+}
+
+OfflineMap::OfflineMap(const QString &fileName, Tar &tar, QObject *parent)
+  : Map(parent)
+{
+	QList<ReferencePoint> points;
+	QString proj, datum;
+	Projection::Setup setup;
+	QFileInfo fi(fileName);
+
+	_valid = false;
+	_img = 0;
+	_projection = 0;
+	_resolution = 0.0;
+	_zoom = 0;
+	_scale = QPointF(1.0, 1.0);
+
+	QFileInfo map(fi.absolutePath());
+	QFileInfo layer(map.absolutePath());
+	QString mapFile = layer.fileName() + "/" + map.fileName() + "/"
+	  + fi.fileName();
+	QByteArray ba = tar.file(mapFile);
+	if (ba.isNull()) {
+		_errorString = "Map file not found";
+		return;
+	}
+	QBuffer buffer(&ba);
+
+	if (!parseMapFile(buffer, points, proj, setup, datum))
+		return;
+	if (!createProjection(datum, proj, setup, points))
+		return;
+	if (!totalSizeSet())
+		return;
+	if (!computeTransformation(points))
+		return;
+	computeResolution(points);
+
+
+	_tarPath = fi.absolutePath() + "/" + fi.completeBaseName() + ".tar";
+	_imgPath = QString();
+	_valid = true;
+}
+
+OfflineMap::~OfflineMap()
+{
+	if (_img)
+		delete _img;
+	if (_projection)
+		delete _projection;
+}
+
+void OfflineMap::load()
+{
+	if (!_tarPath.isNull() && !_tileSize.isValid()) {
+		if (!_tar.load(_tarPath)) {
+			qWarning("%s: error loading tar file", qPrintable(_tarPath));
+			return;
+		}
+		if (!getTileInfo(_tar.files()))
+			qWarning("%s: %s", qPrintable(_tarPath), qPrintable(_errorString));
+		return;
+	}
+
+	if (!_img && !_imgPath.isNull() && !_ozf.isOpen()) {
+		_img = new QImage(_imgPath);
+		if (_img->isNull())
+			qWarning("%s: error loading map image", qPrintable(_imgPath));
+	}
+}
+
+void OfflineMap::unload()
+{
+	if (_img) {
+		delete _img;
+		_img = 0;
+	}
+}
+
+void OfflineMap::drawTiled(QPainter *painter, const QRectF &rect)
+{
+	QPoint tl = QPoint((int)floor(rect.left() / (qreal)_tileSize.width())
+	  * _tileSize.width(), (int)floor(rect.top() / _tileSize.height())
+	  * _tileSize.height());
+
+	QSizeF s(rect.right() - tl.x(), rect.bottom() - tl.y());
+	for (int i = 0; i < ceil(s.width() / _tileSize.width()); i++) {
+		for (int j = 0; j < ceil(s.height() / _tileSize.height()); j++) {
+			int x = tl.x() + i * _tileSize.width();
+			int y = tl.y() + j * _tileSize.height();
+
+			if (!QRectF(QPointF(x, y), _tileSize).intersects(bounds())) {
+				painter->fillRect(QRectF(QPoint(x, y), _tileSize),
+				  _backgroundColor);
+				continue;
+			}
+
+			QString tileName(_tileName.arg(QString::number(x),
+			  QString::number(y)));
+			QPixmap pixmap;
+
+			if (_tar.isOpen()) {
+				QString key = _tar.fileName() + "/" + tileName;
+				if (!QPixmapCache::find(key, &pixmap)) {
+					QByteArray ba = _tar.file(tileName);
+					pixmap = QPixmap::fromImage(QImage::fromData(ba));
+					if (!pixmap.isNull())
+						QPixmapCache::insert(key, pixmap);
+				}
+			} else
+				pixmap = QPixmap(tileName);
+
+			if (pixmap.isNull()) {
+				qWarning("%s: error loading tile image", qPrintable(
+				  _tileName.arg(QString::number(x), QString::number(y))));
+				painter->fillRect(QRectF(QPoint(x, y), _tileSize),
+				  _backgroundColor);
+			} else
+				painter->drawPixmap(QPoint(x, y), pixmap);
+		}
+	}
+}
+
+void OfflineMap::drawOZF(QPainter *painter, const QRectF &rect)
+{
+	QPoint tl = QPoint((int)floor(rect.left() / _ozf.tileSize().width())
+	  * _ozf.tileSize().width(), (int)floor(rect.top()
+	  / _ozf.tileSize().height()) * _ozf.tileSize().height());
+
+	QSizeF s(rect.right() - tl.x(), rect.bottom() - tl.y());
+	for (int i = 0; i < ceil(s.width() / _ozf.tileSize().width()); i++) {
+		for (int j = 0; j < ceil(s.height() / _ozf.tileSize().height()); j++) {
+			int x = tl.x() + i * _ozf.tileSize().width();
+			int y = tl.y() + j * _ozf.tileSize().height();
+
+			if (!QRectF(QPointF(x, y), _ozf.tileSize()).intersects(bounds())) {
+				painter->fillRect(QRectF(QPoint(x, y), _ozf.tileSize()),
+				  _backgroundColor);
+				continue;
+			}
+
+			QPixmap pixmap;
+			QString key = _ozf.fileName() + "/" + QString::number(_zoom) + "_"
+			  + QString::number(x) + "_" + QString::number(y);
+			if (!QPixmapCache::find(key, &pixmap)) {
+				pixmap = _ozf.tile(_zoom, x, y);
+				if (!pixmap.isNull())
+					QPixmapCache::insert(key, pixmap);
+			}
+
+			if (pixmap.isNull()) {
+				qWarning("%s: error loading tile image", qPrintable(key));
+				painter->fillRect(QRectF(QPoint(x, y), _ozf.tileSize()),
+				  _backgroundColor);
+			} else
+				painter->drawPixmap(QPoint(x, y), pixmap);
+		}
+	}
+}
+
+void OfflineMap::drawImage(QPainter *painter, const QRectF &rect)
+{
+	if (!_img || _img->isNull())
+		painter->fillRect(rect, _backgroundColor);
+	else {
+		QRect r(rect.toRect());
+		painter->drawImage(r.left(), r.top(), *_img, r.left(), r.top(),
+		  r.width(), r.height());
+	}
+}
+
+void OfflineMap::draw(QPainter *painter, const QRectF &rect)
+{
+	if (_ozf.isOpen())
+		drawOZF(painter, rect);
+	else if (_tileSize.isValid())
+		drawTiled(painter, rect);
+	else
+		drawImage(painter, rect);
+}
+
+QPointF OfflineMap::ll2xy(const Coordinates &c)
+{
+	if (_ozf.isOpen()) {
+		QPointF p(_transform.map(_projection->ll2xy(c)));
+		return QPointF(p.x() * _scale.x(), p.y() * _scale.y());
+	} else
+		return _transform.map(_projection->ll2xy(c));
+}
+
+Coordinates OfflineMap::xy2ll(const QPointF &p)
+{
+	if (_ozf.isOpen()) {
+		return _projection->xy2ll(_inverted.map(QPointF(p.x() / _scale.x(),
+		  p.y() / _scale.y())));
+	} else
+		return _projection->xy2ll(_inverted.map(p));
+}
+
+QRectF OfflineMap::bounds() const
+{
+	if (_ozf.isOpen())
+		return QRectF(QPointF(0, 0), _ozf.size(_zoom));
+	else
+		return QRectF(QPointF(0, 0), _size);
+}
+
+qreal OfflineMap::resolution(const QPointF &p) const
+{
+	Q_UNUSED(p);
+
+	if (_ozf.isOpen())
+		return _resolution / ((_scale.x() + _scale.y()) / 2.0);
+	else
+		return _resolution;
+}
+
+qreal OfflineMap::zoomFit(const QSize &size, const RectC &br)
+{
+	if (_ozf.isOpen()) {
+		if (!br.isValid())
+			rescale(0);
+		else {
+			QRect sbr(QRectF(_transform.map(_projection->ll2xy(br.topLeft())),
+			  _transform.map(_projection->ll2xy(br.bottomRight())))
+			  .toRect().normalized());
+
+			for (int i = 0; i < _ozf.zooms(); i++) {
+				rescale(i);
+				if (sbr.size().width() * _scale.x() <= size.width()
+				  && sbr.size().height() * _scale.y() <= size.height())
+					break;
+			}
+		}
+	}
+
+	return _zoom;
+}
+
+qreal OfflineMap::zoomFit(qreal resolution, const Coordinates &c)
+{
+	Q_UNUSED(c);
+
+	if (_ozf.isOpen()) {
+		for (int i = 0; i < _ozf.zooms(); i++) {
+			rescale(i);
+			qreal sr = _resolution / ((_scale.x() + _scale.y()) / 2.0);
+			if (sr >= resolution)
+				break;
+		}
+	}
+
+	return _zoom;
+}
+
+qreal OfflineMap::zoomIn()
+{
+	if (_ozf.isOpen())
+		rescale(qMax(_zoom - 1, 0));
+
+	return _zoom;
+}
+
+qreal OfflineMap::zoomOut()
+{
+	if (_ozf.isOpen())
+		rescale(qMin(_zoom + 1, _ozf.zooms() - 1));
+
+	return _zoom;
+}
+
+void OfflineMap::rescale(int zoom)
+{
+	_zoom = zoom;
+	_scale = QPointF(
+	  (qreal)_ozf.size(_zoom).width() / (qreal)_ozf.size(0).width(),
+	  (qreal)_ozf.size(_zoom).height() / (qreal)_ozf.size(0).height());
+}

src/map/offlinemap.h

@@ -0,0 +1,100 @@
+#ifndef OFFLINEMAP_H
+#define OFFLINEMAP_H
+
+#include <QTransform>
+#include "common/coordinates.h"
+#include "projection.h"
+#include "map.h"
+#include "tar.h"
+#include "ozf.h"
+
+class QIODevice;
+class QImage;
+
+class OfflineMap : public Map
+{
+	Q_OBJECT
+
+public:
+	OfflineMap(const QString &fileName, QObject *parent = 0);
+	OfflineMap(const QString &fileName, Tar &tar, QObject *parent = 0);
+	~OfflineMap();
+
+	const QString &name() const {return _name;}
+
+	QRectF bounds() const;
+	qreal resolution(const QPointF &p) const;
+
+	qreal zoom() const {return _zoom;}
+	qreal zoomFit(const QSize &size, const RectC &br);
+	qreal zoomFit(qreal resolution, const Coordinates &c);
+	qreal zoomIn();
+	qreal zoomOut();
+
+	QPointF ll2xy(const Coordinates &c);
+	Coordinates xy2ll(const QPointF &p);
+
+	void draw(QPainter *painter, const QRectF &rect);
+
+	void load();
+	void unload();
+
+	bool isValid() const {return _valid;}
+	const QString &errorString() const {return _errorString;}
+
+	QPointF ll2pp(const Coordinates &c) const
+	  {return _projection->ll2xy(c);}
+	QPointF xy2pp(const QPointF &p) const
+	  {return _inverted.map(p);}
+	QPointF pp2xy(const QPointF &p) const
+	  {return _transform.map(p);}
+
+private:
+	struct ReferencePoint {
+		QPoint xy;
+		Coordinates ll;
+		QPointF pp;
+	};
+
+	int parse(QIODevice &device, QList<ReferencePoint> &points,
+	  QString &projection, Projection::Setup &setup, QString &datum);
+	bool parseMapFile(QIODevice &device, QList<ReferencePoint> &points,
+	  QString &projection, Projection::Setup &setup, QString &datum);
+	bool totalSizeSet();
+	bool createProjection(const QString &datum, const QString &projection,
+	  const Projection::Setup &setup, QList<ReferencePoint> &points);
+	bool simpleTransformation(const QList<ReferencePoint> &points);
+	bool affineTransformation(const QList<ReferencePoint> &points);
+	bool computeTransformation(const QList<ReferencePoint> &points);
+	bool computeResolution(QList<ReferencePoint> &points);
+	bool getTileInfo(const QStringList &tiles, const QString &path = QString());
+	bool getImageInfo(const QString &path);
+
+	void drawTiled(QPainter *painter, const QRectF &rect);
+	void drawOZF(QPainter *painter, const QRectF &rect);
+	void drawImage(QPainter *painter, const QRectF &rect);
+
+	void rescale(int zoom);
+
+	QString _name;
+	bool _valid;
+	QString _errorString;
+
+	QSize _size;
+	Projection *_projection;
+	QTransform _transform, _inverted;
+	qreal _resolution;
+
+	OZF _ozf;
+	Tar _tar;
+	QString _tarPath;
+	QImage *_img;
+	QString _imgPath;
+	QSize _tileSize;
+	QString _tileName;
+
+	int _zoom;
+	QPointF _scale;
+};
+
+#endif // OFFLINEMAP_H

src/map/onlinemap.cpp

@@ -0,0 +1,268 @@
+#include <QFileInfo>
+#include <QDir>
+#include <QPainter>
+#include "common/coordinates.h"
+#include "common/rectc.h"
+#include "common/wgs84.h"
+#include "mercator.h"
+#include "downloader.h"
+#include "config.h"
+#include "misc.h"
+#include "onlinemap.h"
+
+
+#define TILE_SIZE     256
+
+static QPoint mercator2tile(const QPointF &m, int z)
+{
+	QPoint tile;
+
+	tile.setX((int)(floor((m.x() + 180.0) / 360.0 * (1<<z))));
+	tile.setY((int)(floor((1.0 - (m.y() / 180.0)) / 2.0 * (1<<z))));
+
+	return tile;
+}
+
+static qreal zoom2scale(int zoom)
+{
+	return (360.0/(qreal)((1<<zoom) * TILE_SIZE));
+}
+
+static int scale2zoom(qreal scale)
+{
+	return (int)log2(360.0/(scale * (qreal)TILE_SIZE));
+}
+
+static bool loadTileFile(Tile &tile, const QString &file)
+{
+	if (!tile.pixmap().load(file)) {
+		qWarning("%s: error loading tile file\n", qPrintable(file));
+		return false;
+	}
+
+	return true;
+}
+
+
+Downloader *OnlineMap::downloader;
+
+OnlineMap::OnlineMap(const QString &name, const QString &url,
+  const Range &zooms, QObject *parent) : Map(parent)
+{
+	_name = name;
+	_url = url;
+	_block = false;
+	_zooms = zooms;
+	_zoom = zooms.max();
+
+	QString path = TILES_DIR + QString("/") + name;
+	if (!QDir().mkpath(path))
+		qWarning("Error creating tiles dir: %s\n", qPrintable(path));
+}
+
+void OnlineMap::load()
+{
+	connect(downloader, SIGNAL(finished()), this, SLOT(emitLoaded()));
+}
+
+void OnlineMap::unload()
+{
+	disconnect(downloader, SIGNAL(finished()), this, SLOT(emitLoaded()));
+}
+
+void OnlineMap::fillTile(Tile &tile)
+{
+	tile.pixmap() = QPixmap(TILE_SIZE, TILE_SIZE);
+	tile.pixmap().fill(_backgroundColor);
+}
+
+void OnlineMap::emitLoaded()
+{
+	emit loaded();
+}
+
+void OnlineMap::loadTilesAsync(QList<Tile> &list)
+{
+	QList<Download> dl;
+
+	for (int i = 0; i < list.size(); i++) {
+		Tile &t = list[i];
+		QString file = tileFile(t);
+		QFileInfo fi(file);
+
+		if (!fi.exists()) {
+			fillTile(t);
+			dl.append(Download(tileUrl(t), file));
+		} else
+			loadTileFile(t, file);
+	}
+
+	if (!dl.empty())
+		downloader->get(dl);
+}
+
+void OnlineMap::loadTilesSync(QList<Tile> &list)
+{
+	QList<Download> dl;
+
+	for (int i = 0; i < list.size(); i++) {
+		Tile &t = list[i];
+		QString file = tileFile(t);
+		QFileInfo fi(file);
+
+		if (!fi.exists())
+			dl.append(Download(tileUrl(t), file));
+		else
+			loadTileFile(t, file);
+	}
+
+	if (dl.empty())
+		return;
+
+	QEventLoop wait;
+	connect(downloader, SIGNAL(finished()), &wait, SLOT(quit()));
+	if (downloader->get(dl))
+		wait.exec();
+
+	for (int i = 0; i < list.size(); i++) {
+		Tile &t = list[i];
+
+		if (t.pixmap().isNull()) {
+			QString file = tileFile(t);
+			QFileInfo fi(file);
+
+			if (!(fi.exists() && loadTileFile(t, file)))
+				fillTile(t);
+		}
+	}
+}
+
+QString OnlineMap::tileUrl(const Tile &tile) const
+{
+	QString url(_url);
+
+	url.replace("$z", QString::number(tile.zoom()));
+	url.replace("$x", QString::number(tile.xy().x()));
+	url.replace("$y", QString::number(tile.xy().y()));
+
+	return url;
+}
+
+QString OnlineMap::tileFile(const Tile &tile) const
+{
+	QString file = TILES_DIR + QString("/%1/%2-%3-%4").arg(name())
+	  .arg(tile.zoom()).arg(tile.xy().x()).arg(tile.xy().y());
+
+	return file;
+}
+
+void OnlineMap::clearCache()
+{
+	QString path = TILES_DIR + QString("/") + name();
+	QDir dir = QDir(path);
+	QStringList list = dir.entryList();
+
+	for (int i = 0; i < list.count(); i++)
+		dir.remove(list.at(i));
+}
+
+QRectF OnlineMap::bounds() const
+{
+	return scaled(QRectF(QPointF(-180, -180), QSizeF(360, 360)),
+	  1.0/zoom2scale(_zoom));
+}
+
+int OnlineMap::limitZoom(int zoom) const
+{
+	if (zoom < _zooms.min())
+		return _zooms.min();
+	if (zoom > _zooms.max())
+		return _zooms.max();
+
+	return zoom;
+}
+
+qreal OnlineMap::zoomFit(const QSize &size, const RectC &br)
+{
+	if (!br.isValid())
+		_zoom = _zooms.max();
+	else {
+		QRectF tbr(Mercator().ll2xy(br.topLeft()),
+		  Mercator().ll2xy(br.bottomRight()));
+		QPointF sc(tbr.width() / size.width(), tbr.height() / size.height());
+
+		_zoom = limitZoom(scale2zoom(qMax(sc.x(), sc.y())));
+	}
+
+	return _zoom;
+}
+
+qreal OnlineMap::zoomFit(qreal resolution, const Coordinates &c)
+{
+	_zoom = limitZoom((int)(log2((WGS84_RADIUS * 2 * M_PI
+	  * cos(deg2rad(c.lat()))) / resolution) - log2(TILE_SIZE)));
+
+	return _zoom;
+}
+
+qreal OnlineMap::resolution(const QPointF &p) const
+{
+	qreal scale = zoom2scale(_zoom);
+
+	return (WGS84_RADIUS * 2 * M_PI * scale / 360.0
+	  * cos(2.0 * atan(exp(deg2rad(-p.y() * scale))) - M_PI/2));
+}
+
+qreal OnlineMap::zoomIn()
+{
+	_zoom = qMin(_zoom + 1, _zooms.max());
+	return _zoom;
+}
+
+qreal OnlineMap::zoomOut()
+{
+	_zoom = qMax(_zoom - 1, _zooms.min());
+	return _zoom;
+}
+
+void OnlineMap::draw(QPainter *painter, const QRectF &rect)
+{
+	qreal scale = zoom2scale(_zoom);
+
+	QPoint tile = mercator2tile(QPointF(rect.topLeft().x() * scale,
+	  -rect.topLeft().y() * scale), _zoom);
+	QPoint tl = QPoint((int)floor(rect.left() / (qreal)TILE_SIZE)
+	  * TILE_SIZE, (int)floor(rect.top() / TILE_SIZE) * TILE_SIZE);
+
+	QList<Tile> tiles;
+	QSizeF s(rect.right() - tl.x(), rect.bottom() - tl.y());
+	for (int i = 0; i < ceil(s.width() / TILE_SIZE); i++)
+		for (int j = 0; j < ceil(s.height() / TILE_SIZE); j++)
+			tiles.append(Tile(QPoint(tile.x() + i, tile.y() + j), _zoom));
+
+	if (_block)
+		loadTilesSync(tiles);
+	else
+		loadTilesAsync(tiles);
+
+	for (int i = 0; i < tiles.count(); i++) {
+		Tile &t = tiles[i];
+		QPoint tp(tl.x() + (t.xy().x() - tile.x()) * TILE_SIZE,
+		  tl.y() + (t.xy().y() - tile.y()) * TILE_SIZE);
+		painter->drawPixmap(tp, t.pixmap());
+	}
+}
+
+QPointF OnlineMap::ll2xy(const Coordinates &c)
+{
+	qreal scale = zoom2scale(_zoom);
+	QPointF m = Mercator().ll2xy(c);
+	return QPointF(m.x() / scale, m.y() / -scale);
+}
+
+Coordinates OnlineMap::xy2ll(const QPointF &p)
+{
+	qreal scale = zoom2scale(_zoom);
+	QPointF m(p.x() * scale, -p.y() * scale);
+	return Mercator().xy2ll(m);
+}

src/map/onlinemap.h

@@ -0,0 +1,63 @@
+#ifndef ONLINEMAP_H
+#define ONLINEMAP_H
+
+#include "common/range.h"
+#include "map.h"
+#include "tile.h"
+
+class Downloader;
+
+class OnlineMap : public Map
+{
+	Q_OBJECT
+
+public:
+	OnlineMap(const QString &name, const QString &url, const Range &zooms,
+	  QObject *parent = 0);
+
+	const QString &name() const {return _name;}
+
+	QRectF bounds() const;
+	qreal resolution(const QPointF &p) const;
+
+	qreal zoom() const {return _zoom;}
+	qreal zoomFit(const QSize &size, const RectC &br);
+	qreal zoomFit(qreal resolution, const Coordinates &c);
+	qreal zoomIn();
+	qreal zoomOut();
+
+	QPointF ll2xy(const Coordinates &c);
+	Coordinates xy2ll(const QPointF &p);
+
+	void draw(QPainter *painter, const QRectF &rect);
+
+	void setBlockingMode(bool block) {_block = block;}
+	void clearCache();
+
+	static void setDownloader(Downloader *downloader)
+	  {OnlineMap::downloader = downloader;}
+
+	void load();
+	void unload();
+
+private slots:
+	void emitLoaded();
+
+private:
+	void fillTile(Tile &tile);
+	QString tileUrl(const Tile &tile) const;
+	QString tileFile(const Tile &tile) const;
+	void loadTilesAsync(QList<Tile> &list);
+	void loadTilesSync(QList<Tile> &list);
+	int limitZoom(int zoom) const;
+
+	Range _zooms;
+	int _zoom;
+	QString _name;
+	QString _url;
+	bool _block;
+
+	static Downloader *downloader;
+};
+
+#endif // ONLINEMAP_H

src/map/ozf.cpp

@@ -0,0 +1,268 @@
+#include <cstring>
+#include <QtEndian>
+#include <QFile>
+#include "ozf.h"
+
+
+#define OZF2_MAGIC  0x7778
+#define OZF3_MAGIC  0x7780
+
+static const quint8 XKEY[] =
+{
+	0x2D, 0x4A, 0x43, 0xF1, 0x27, 0x9B, 0x69, 0x4F,
+	0x36, 0x52, 0x87, 0xEC, 0x5F, 0x42, 0x53, 0x22,
+	0x9E, 0x8B, 0x2D, 0x83, 0x3D, 0xD2, 0x84, 0xBA,
+	0xD8, 0x5B
+};
+
+static void decrypt(void *data, size_t size, quint8 init)
+{
+	for (size_t i = 0; i < size; i++)
+		reinterpret_cast<quint8*>(data)[i] ^= XKEY[i % sizeof(XKEY)] + init;
+}
+
+template<class T> bool OZF::readValue(T &val)
+{
+	T data;
+
+	if (_file.read((char*)&data, sizeof(T)) < (qint64)sizeof(T))
+		return false;
+
+	if (_decrypt)
+		decrypt(&data, sizeof(T), _key);
+
+	if (sizeof(T) > 1)
+		val = qFromLittleEndian(data);
+	else
+		val = data;
+
+	return true;
+}
+
+bool OZF::read(void *data, size_t size, size_t decryptSize)
+{
+	if (_file.read((char*)data, size) < (qint64)size)
+		return false;
+
+	if (_decrypt)
+		decrypt(data, decryptSize ? qMin(decryptSize, size) : size, _key);
+
+	return true;
+}
+
+bool OZF::initOZF3()
+{
+	quint8 randomNumber, initial;
+	quint8 h1[8];
+	quint8 h2[16], h2d[16];
+
+
+	if (!_file.seek(14))
+		return false;
+	if (!readValue(randomNumber))
+		return false;
+
+	if (!_file.seek(162))
+		return false;
+	if (!readValue(initial))
+		return false;
+
+	_decrypt = true;
+	_key = initial;
+
+	if (!_file.seek(0))
+		return false;
+	if (!read(h1, sizeof(h1)))
+		return false;
+	_tileSize = *(h1 + 6);
+
+	if (!_file.seek(15 + randomNumber + 4))
+		return false;
+	if (_file.read((char*)h2, sizeof(h2)) != (qint64)sizeof(h2))
+		return false;
+
+	for (int i = 0; i < 256; i++) {
+		memcpy(h2d, h2, sizeof(h2d));
+		decrypt(h2d, sizeof(h2d), (quint8)i);
+
+		if ((quint32)*h2d == 40 && (quint16)*(h2d + 12) == 1
+		  && (quint16)*(h2d + 14) == 8) {
+			_key = (quint8)i;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool OZF::initOZF2()
+{
+	if (!_file.seek(6))
+		return false;
+	if (!readValue(_tileSize))
+		return false;
+
+	return true;
+}
+
+bool OZF::readHeaders()
+{
+	quint16 magic;
+
+	if (!readValue(magic))
+		return false;
+
+	if (magic == OZF2_MAGIC) {
+		if (!initOZF2())
+			return false;
+	} else if (magic == OZF3_MAGIC) {
+		if (!initOZF3())
+			return false;
+	} else {
+		qWarning("%s: not a OZF2/OZF3 file", qPrintable(_file.fileName()));
+		return false;
+	}
+
+	return true;
+}
+
+bool OZF::readTileTable()
+{
+	quint32 tableOffset, headerOffset, bgr0, w, h;
+	quint16 x, y;
+	int zooms;
+
+
+	if (!_file.seek(_file.size() - sizeof(tableOffset)))
+		return false;
+	if (!readValue(tableOffset))
+		return false;
+	zooms = (int)((_file.size() - tableOffset - sizeof(quint32))
+	  / sizeof(quint32));
+
+	for (int i = 0; i < zooms - 2; i++) {
+		if (!_file.seek(tableOffset + i * sizeof(quint32)))
+			return false;
+		if (!readValue(headerOffset))
+			return false;
+		if (!_file.seek(headerOffset))
+			return false;
+
+		if (!readValue(w))
+			return false;
+		if (!readValue(h))
+			return false;
+		if (!readValue(x))
+			return false;
+		if (!readValue(y))
+			return false;
+
+		Zoom zoom;
+		zoom.size = QSize(w, h);
+		zoom.dim = QSize(x, y);
+
+		zoom.palette = QVector<quint32>(256);
+		if (!read(&(zoom.palette[0]), sizeof(quint32) * 256))
+			return false;
+		for (int i = 0; i < zoom.palette.size(); i++) {
+			bgr0 = qFromLittleEndian(zoom.palette.at(i));
+
+			quint32 b = (bgr0 & 0x000000FF);
+			quint32 g = (bgr0 & 0x0000FF00) >> 8;
+			quint32 r = (bgr0 & 0x00FF0000) >> 16;
+
+			zoom.palette[i] = 0xFF000000 | r << 16 | g << 8 | b;
+		}
+
+		zoom.tiles = QVector<quint32>(zoom.dim.width() * zoom.dim.height() + 1);
+		for (int i = 0; i < zoom.tiles.size(); i++)
+			if (!readValue(zoom.tiles[i]))
+				return false;
+
+		_zooms.append(zoom);
+	}
+
+	return _zooms.isEmpty() ? false : true;
+}
+
+bool OZF::load(const QString &path)
+{
+	if (_file.isOpen())
+		_file.close();
+
+	_file.setFileName(path);
+	if (!_file.open(QIODevice::ReadOnly))
+		return false;
+
+	if (!readHeaders()) {
+		qWarning("%s: Invalid header", qPrintable(_file.fileName()));
+		_file.close();
+		return false;
+	}
+
+	if (!readTileTable()) {
+		qWarning("%s: Invalid tile table", qPrintable(_file.fileName()));
+		_file.close();
+		return false;
+	}
+
+	return true;
+}
+
+QPixmap OZF::tile(int zoom, int x, int y)
+{
+	Q_ASSERT(_file.isOpen());
+	Q_ASSERT(0 <= zoom && zoom < _zooms.count());
+
+	const Zoom &z = _zooms.at(zoom);
+
+	int i = (y/tileSize().height()) * z.dim.width() + (x/tileSize().width());
+	if (i >= z.tiles.size() - 1 || i < 0)
+		return QPixmap();
+
+	int size = z.tiles.at(i+1) - z.tiles.at(i);
+	if (!_file.seek(z.tiles.at(i)))
+		return QPixmap();
+
+	quint32 bes = qToBigEndian(tileSize().width() * tileSize().height());
+	QByteArray ba;
+	ba.resize(sizeof(bes) + size);
+	*(ba.data()) = bes;
+
+	if (!read(ba.data() + sizeof(bes), size, 16))
+		return QPixmap();
+	QByteArray uba = qUncompress(ba);
+	if (uba.size() != tileSize().width() * tileSize().height())
+		return QPixmap();
+
+	QImage img((const uchar*)uba.constData(), tileSize().width(),
+	  tileSize().height(), QImage::Format_Indexed8);
+	img.setColorTable(z.palette);
+
+	return QPixmap::fromImage(img.mirrored());
+}
+
+QSize OZF::size(int zoom) const
+{
+	Q_ASSERT(_file.isOpen());
+	Q_ASSERT(0 <= zoom && zoom < _zooms.count());
+
+	return _zooms.at(zoom).size;
+}
+
+bool OZF::isOZF(const QString &path)
+{
+	QFile file(path);
+	quint16 magic;
+
+	if (!file.open(QIODevice::ReadOnly))
+		return false;
+	if (file.read((char*)&magic, sizeof(magic)) < (qint64)sizeof(magic))
+		return false;
+
+	magic = qFromLittleEndian(magic);
+	if (magic == OZF2_MAGIC || magic == OZF3_MAGIC)
+		return true;
+
+	return false;
+}

src/map/ozf.h

@@ -0,0 +1,51 @@
+#ifndef OZF_H
+#define OZF_H
+
+#include <QString>
+#include <QSize>
+#include <QColor>
+#include <QList>
+#include <QVector>
+#include <QFile>
+#include <QPixmap>
+
+class OZF
+{
+public:
+	OZF() : _tileSize(0), _decrypt(false), _key(0) {}
+
+	bool load(const QString &path);
+
+	QString fileName() const {return _file.fileName();}
+	bool isOpen() const {return _file.isOpen();}
+
+	int zooms() const {return _zooms.size();}
+	QSize size(int zoom) const;
+	QSize tileSize() const {return QSize(_tileSize, _tileSize);}
+	QPixmap tile(int zoom, int x, int y);
+
+	static bool isOZF(const QString &path);
+
+private:
+	struct Zoom {
+		QSize size;
+		QSize dim;
+		QVector<QRgb> palette;
+		QVector<quint32> tiles;
+	};
+
+	template<class T> bool readValue(T &val);
+	bool read(void *data, size_t size, size_t decryptSize = 0);
+	bool initOZF3();
+	bool initOZF2();
+	bool readHeaders();
+	bool readTileTable();
+
+	quint16 _tileSize;
+	bool _decrypt;
+	quint8 _key;
+	QList<Zoom> _zooms;
+	QFile _file;
+};
+
+#endif // OZF_H

src/map/projection.cpp

@@ -0,0 +1,89 @@
+#include "latlon.h"
+#include "mercator.h"
+#include "transversemercator.h"
+#include "utm.h"
+#include "lambertconic.h"
+#include "albersequal.h"
+#include "lambertazimuthal.h"
+
+
+QString Projection::_errorString;
+
+Projection *Projection::projection(const QString &name,
+  const Ellipsoid &ellipsoid, const Setup &setup)
+{
+	if (setup.latitudeOrigin < -90.0 || setup.latitudeOrigin > 90.0
+	  || setup.longitudeOrigin < -180.0 || setup.longitudeOrigin > 180.0
+	  || setup.standardParallel1 < -90.0 || setup.standardParallel1 > 90.0
+	  || setup.standardParallel2 < -90.0 || setup.standardParallel2 > 90.0) {
+		_errorString = "Invalid projection setup";
+		return 0;
+	}
+
+	if (name == "Mercator")
+		return new Mercator();
+	else if (name == "Transverse Mercator")
+		return new TransverseMercator(ellipsoid,
+		  setup.latitudeOrigin, setup.longitudeOrigin, setup.scale,
+		  setup.falseEasting, setup.falseNorthing);
+	else if (name == "Latitude/Longitude")
+		return new LatLon();
+	else if (name == "Lambert Conformal Conic")
+		return new LambertConic(ellipsoid,
+		  setup.standardParallel1, setup.standardParallel2,
+		  setup.latitudeOrigin, setup.longitudeOrigin, setup.scale,
+		  setup.falseEasting, setup.falseNorthing);
+	else if (name == "Albers Equal Area")
+		return new AlbersEqual(ellipsoid, setup.standardParallel1,
+		  setup.standardParallel2, setup.latitudeOrigin, setup.longitudeOrigin,
+		  setup.falseEasting, setup.falseNorthing);
+	else if (name == "(A)Lambert Azimuthual Equal Area")
+		return new LambertAzimuthal(ellipsoid, setup.latitudeOrigin,
+		  setup.longitudeOrigin, setup.falseEasting, setup.falseNorthing);
+	else if (name == "(UTM) Universal Transverse Mercator") {
+		if (setup.zone)
+			return new UTM(ellipsoid, setup.zone);
+		else {
+			_errorString = "Can not determine UTM zone";
+			return 0;
+		}
+	} else if (name == "(NZTM2) New Zealand TM 2000")
+		return new TransverseMercator(ellipsoid, 0, 173.0, 0.9996,
+		  1600000, 10000000);
+	else if (name == "(BNG) British National Grid")
+		return new TransverseMercator(ellipsoid, 49, -2, 0.999601,
+		  400000, -100000);
+	else if (name == "(IG) Irish Grid")
+		return new TransverseMercator(ellipsoid, 53.5, -8, 1.000035,
+		  200000, 250000);
+	else if (name == "(SG) Swedish Grid")
+		return new TransverseMercator(ellipsoid, 0, 15.808278, 1,
+		  1500000, 0);
+	else if (name == "(I) France Zone I")
+		return new LambertConic(ellipsoid, 48.598523, 50.395912,
+		  49.5, 2.337229, 1 /*0.99987734*/, 600000, 1200000);
+	else if (name == "(II) France Zone II")
+		return new LambertConic(ellipsoid, 45.898919, 47.696014,
+		  46.8, 2.337229, 1 /*0.99987742*/, 600000, 2200000);
+	else if (name == "(III) France Zone III")
+		return new LambertConic(ellipsoid, 43.199291, 44.996094,
+		  44.1, 2.337229, 1 /*0.99987750*/, 600000, 3200000);
+	else if (name == "(IV) France Zone IV")
+		return new LambertConic(ellipsoid, 41.560388, 42.767663,
+		  42.165, 2.337229, 1 /*0.99994471*/, 234.358, 4185861.369);
+	else if (name == "(VICGRID) Victoria Australia")
+		return new LambertConic(ellipsoid, -36, -38, -37, 145, 1,
+		  2500000, 4500000);
+	else if (name == "(VG94) VICGRID94 Victoria Australia")
+		return new LambertConic(ellipsoid, -36, -38, -37, 145, 1,
+		  2500000, 2500000);
+	else {
+		_errorString = QString("%1: Unknown map projection").arg(name);
+		return 0;
+	}
+}
+
+const QString &Projection::errorString()
+{
+	return _errorString;
+}

src/map/projection.h

@@ -0,0 +1,36 @@
+#ifndef PROJECTION_H
+#define PROJECTION_H
+
+#include <QPointF>
+#include <QString>
+#include "common/coordinates.h"
+
+class Ellipsoid;
+
+class Projection {
+public:
+	struct Setup {
+		double latitudeOrigin;
+		double longitudeOrigin;
+		double scale;
+		double falseEasting;
+		double falseNorthing;
+		double standardParallel1;
+		double standardParallel2;
+		int zone;
+	};
+
+	virtual ~Projection() {}
+
+	virtual QPointF ll2xy(const Coordinates &c) const = 0;
+	virtual Coordinates xy2ll(const QPointF &p) const = 0;
+
+	static Projection *projection(const QString &name,
+	  const Ellipsoid &ellipsoid, const Setup &setup);
+	static const QString &errorString();
+
+private:
+	static QString _errorString;
+};
+
+#endif // PROJECTION_H

src/map/tar.cpp

@@ -0,0 +1,136 @@
+#include <cctype>
+#include <QFile>
+#include <QFileInfo>
+#include "tar.h"
+
+
+#define BLOCKSIZE 512
+
+#define BLOCKCOUNT(size) \
+	((size)/BLOCKSIZE + ((size) % BLOCKSIZE > 0 ? 1 : 0))
+
+struct Header
+{
+	char name[100];               /*   0 */
+	char mode[8];                 /* 100 */
+	char uid[8];                  /* 108 */
+	char gid[8];                  /* 116 */
+	char size[12];                /* 124 */
+	char mtime[12];               /* 136 */
+	char chksum[8];               /* 148 */
+	char typeflag;                /* 156 */
+	char linkname[100];           /* 157 */
+	char magic[6];                /* 257 */
+	char version[2];              /* 263 */
+	char uname[32];               /* 265 */
+	char gname[32];               /* 297 */
+	char devmajor[8];             /* 329 */
+	char devminor[8];             /* 337 */
+	char prefix[155];             /* 345 */
+	                              /* 500 */
+};
+
+static quint64 number(const char* data, size_t size, int base = 8)
+{
+	const char *sp;
+	quint64 val = 0;
+
+	for (sp = data; sp < data + size; sp++)
+		if (isdigit(*sp))
+			break;
+	for (; sp < data + size && isdigit(*sp); sp++)
+		val = val * base + *sp - '0';
+
+	return val;
+}
+
+bool Tar::load(const QString &path)
+{
+	if (_file.isOpen())
+		_file.close();
+	_index.clear();
+
+	_file.setFileName(path);
+	if (!_file.open(QIODevice::ReadOnly))
+		return false;
+
+	QFileInfo fi(path);
+	QString tmiPath = fi.path() + "/" + fi.completeBaseName() + ".tmi";
+
+	if (loadTmi(tmiPath))
+		return true;
+	else
+		return loadTar();
+}
+
+bool Tar::loadTar()
+{
+	char buffer[BLOCKSIZE];
+	struct Header *hdr = (struct Header*)&buffer;
+	quint64 size;
+	qint64 ret;
+
+	while ((ret = _file.read(buffer, BLOCKSIZE)) > 0) {
+		if (ret < BLOCKSIZE) {
+			_file.close();
+			_index.clear();
+			return false;
+		}
+		size = number(hdr->size, sizeof(hdr->size));
+		_index.insert(hdr->name, _file.pos() / BLOCKSIZE - 1);
+		if (!_file.seek(_file.pos() + BLOCKCOUNT(size) * BLOCKSIZE)) {
+			_file.close();
+			_index.clear();
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool Tar::loadTmi(const QString &path)
+{
+	quint64 block;
+	int ln = 1;
+
+	QFile file(path);
+	if (!file.open(QIODevice::ReadOnly))
+		return false;
+
+	while (!file.atEnd()) {
+		QByteArray line = file.readLine();
+		int pos = line.indexOf(':');
+		if (line.size() < 10 || pos < 7 || !line.startsWith("block")) {
+			qWarning("%s:%d: syntax error\n", qPrintable(path), ln);
+			_index.clear();
+			return false;
+		}
+		block = number(line.constData() + 6, line.size() - 6, 10);
+		QString file(line.mid(pos + 1).trimmed());
+
+		_index.insert(file, block);
+		ln++;
+	}
+
+	return true;
+}
+
+QByteArray Tar::file(const QString &name)
+{
+	char buffer[BLOCKSIZE];
+	struct Header *hdr = (struct Header*)&buffer;
+	quint64 size;
+
+	QMap<QString, quint64>::const_iterator it = _index.find(name);
+	if (it == _index.end())
+		return QByteArray();
+
+	Q_ASSERT(_file.isOpen());
+	if (_file.seek(it.value() * BLOCKSIZE)) {
+		if (_file.read(buffer, BLOCKSIZE) < BLOCKSIZE)
+			return QByteArray();
+		size = number(hdr->size, sizeof(hdr->size));
+		return _file.read(size);
+	} else
+		return QByteArray();
+}

src/map/tar.h

@@ -0,0 +1,27 @@
+#ifndef TAR_H
+#define TAR_H
+
+#include <QStringList>
+#include <QMap>
+#include <QFile>
+
+class Tar
+{
+public:
+	bool load(const QString &path);
+
+	QStringList files() const {return _index.keys();}
+	QByteArray file(const QString &name);
+
+	QString fileName() const {return _file.fileName();}
+	bool isOpen() const {return _file.isOpen();}
+
+private:
+	bool loadTar();
+	bool loadTmi(const QString &path);
+
+	QFile _file;
+	QMap<QString, quint64> _index;
+};
+
+#endif // TAR_H

src/map/tile.h

@@ -0,0 +1,30 @@
+#ifndef TILE_H
+#define TILE_H
+
+#include <QPixmap>
+#include <QPoint>
+#include <QDebug>
+
+class Tile
+{
+public:
+	Tile(const QPoint &xy, int zoom)
+		{_xy = xy; _zoom = zoom;}
+
+	int zoom() const {return _zoom;}
+	const QPoint& xy() const {return _xy;}
+	QPixmap& pixmap() {return _pixmap;}
+
+private:
+	int _zoom;
+	QPoint _xy;
+	QPixmap _pixmap;
+};
+
+inline QDebug operator<<(QDebug dbg, const Tile &tile)
+{
+	dbg.nospace() << "Tile(" << tile.zoom() << ", " << tile.xy() << ")";
+	return dbg.maybeSpace();
+}
+
+#endif // TILE_H

src/map/transversemercator.cpp

@@ -0,0 +1,255 @@
+/*
+ * Based on libgeotrans with the following Source Code Disclaimer:
+
+1. The GEOTRANS source code ("the software") is provided free of charge by
+the National Imagery and Mapping Agency (NIMA) of the United States
+Department of Defense. Although NIMA makes no copyright claim under Title 17
+U.S.C., NIMA claims copyrights in the source code under other legal regimes.
+NIMA hereby grants to each user of the software a license to use and
+distribute the software, and develop derivative works.
+
+2. Warranty Disclaimer: The software was developed to meet only the internal
+requirements of the U.S. National Imagery and Mapping Agency. The software
+is provided "as is," and no warranty, express or implied, including but not
+limited to the implied warranties of merchantability and fitness for
+particular purpose or arising by statute or otherwise in law or from a
+course of dealing or usage in trade, is made by NIMA as to the accuracy and
+functioning of the software.
+
+3. NIMA and its personnel are not required to provide technical support or
+general assistance with respect to the software.
+
+4. Neither NIMA nor its personnel will be liable for any claims, losses, or
+damages arising from or connected with the use of the software. The user
+agrees to hold harmless the United States National Imagery and Mapping
+Agency. The user's sole and exclusive remedy is to stop using the software.
+
+5. NIMA requests that products developed using the software credit the
+source of the software with the following statement, "The product was
+developed using GEOTRANS, a product of the National Imagery and Mapping
+Agency and U.S. Army Engineering Research and Development Center."
+
+6. For any products developed using the software, NIMA requires a disclaimer
+that use of the software does not indicate endorsement or approval of the
+product by the Secretary of Defense or the National Imagery and Mapping
+Agency. Pursuant to the United States Code, 10 U.S.C. Sec. 2797, the name of
+the National Imagery and Mapping Agency, the initials "NIMA", the seal of
+the National Imagery and Mapping Agency, or any colorable imitation thereof
+shall not be used to imply approval, endorsement, or authorization of a
+product without prior written permission from United States Secretary of
+Defense.
+
+*/
+
+#include <cmath>
+#include "ellipsoid.h"
+#include "transversemercator.h"
+
+
+#define SPHSN(lat) \
+	((double)(_e.radius() / sqrt(1.e0 - _es * pow(sin(lat), 2))))
+#define SPHTMD(lat) \
+	((double)(_ap * lat - _bp * sin(2.e0 * lat) + _cp * sin(4.e0 * lat) \
+	  - _dp * sin(6.e0 * lat) + _ep * sin(8.e0 * lat)))
+#define DENOM(lat) \
+	((double)(sqrt(1.e0 - _es * pow(sin(lat),2))))
+#define SPHSR(lat) \
+	((double)(_e.radius() * (1.e0 - _es) / pow(DENOM(lat), 3)))
+
+
+TransverseMercator::TransverseMercator(const Ellipsoid &ellipsoid,
+  double latitudeOrigin, double longitudeOrigin, double scale,
+  double falseEasting, double falseNorthing)
+{
+	double tn, tn2, tn3, tn4, tn5;
+	double b;
+
+
+	_e = ellipsoid;
+	_longitudeOrigin = deg2rad(longitudeOrigin);
+	_latitudeOrigin = deg2rad(latitudeOrigin);
+	_scale = scale;
+	_falseEasting = falseEasting;
+	_falseNorthing = falseNorthing;
+
+	_es = 2 * _e.flattening() - _e.flattening() * _e.flattening();
+	_ebs = (1 / (1 - _es)) - 1;
+
+	b = _e.radius() * (1 - _e.flattening());
+
+	tn = (_e.radius() - b) / (_e.radius() + b);
+	tn2 = tn * tn;
+	tn3 = tn2 * tn;
+	tn4 = tn3 * tn;
+	tn5 = tn4 * tn;
+
+	_ap = _e.radius() * (1.e0 - tn + 5.e0 * (tn2 - tn3) / 4.e0 + 81.e0
+	  * (tn4 - tn5) / 64.e0);
+	_bp = 3.e0 * _e.radius() * (tn - tn2 + 7.e0 * (tn3 - tn4) / 8.e0 + 55.e0
+	  * tn5 / 64.e0 ) / 2.e0;
+	_cp = 15.e0 * _e.radius() * (tn2 - tn3 + 3.e0 * (tn4 - tn5 ) / 4.e0) / 16.0;
+	_dp = 35.e0 * _e.radius() * (tn3 - tn4 + 11.e0 * tn5 / 16.e0) / 48.e0;
+	_ep = 315.e0 * _e.radius() * (tn4 - tn5) / 512.e0;
+}
+
+QPointF TransverseMercator::ll2xy(const Coordinates &c) const
+{
+	double rl;
+	double cl, c2, c3, c5, c7;
+	double dlam;
+	double eta, eta2, eta3, eta4;
+	double sl, sn;
+	double t, tan2, tan3, tan4, tan5, tan6;
+	double t1, t2, t3, t4, t5, t6, t7, t8, t9;
+	double tmd, tmdo;
+	double x, y;
+
+
+	dlam = deg2rad(c.lon()) - _longitudeOrigin;
+
+	if (dlam > M_PI)
+		dlam -= (2 * M_PI);
+	if (dlam < -M_PI)
+		dlam += (2 * M_PI);
+	if (fabs(dlam) < 2.e-10)
+		dlam = 0.0;
+
+	rl = deg2rad(c.lat());
+	sl = sin(rl);
+	cl = cos(rl);
+	c2 = cl * cl;
+	c3 = c2 * cl;
+	c5 = c3 * c2;
+	c7 = c5 * c2;
+	t = sl / cl;
+	tan2 = t * t;
+	tan3 = tan2 * t;
+	tan4 = tan3 * t;
+	tan5 = tan4 * t;
+	tan6 = tan5 * t;
+	eta = _ebs * c2;
+	eta2 = eta * eta;
+	eta3 = eta2 * eta;
+	eta4 = eta3 * eta;
+
+	sn = SPHSN(rl);
+	tmd = SPHTMD(rl);
+	tmdo = SPHTMD (_latitudeOrigin);
+
+
+	t1 = (tmd - tmdo) * _scale;
+	t2 = sn * sl * cl * _scale / 2.e0;
+	t3 = sn * sl * c3 * _scale * (5.e0 - tan2 + 9.e0 * eta + 4.e0 * eta2)
+	  / 24.e0;
+	t4 = sn * sl * c5 * _scale * (61.e0 - 58.e0 * tan2 + tan4 + 270.e0 * eta
+	  - 330.e0 * tan2 * eta + 445.e0 * eta2 + 324.e0 * eta3 - 680.e0 * tan2
+	  * eta2 + 88.e0 * eta4 - 600.e0 * tan2 * eta3 - 192.e0 * tan2 * eta4)
+	  / 720.e0;
+	t5 = sn * sl * c7 * _scale * (1385.e0 - 3111.e0 * tan2 + 543.e0 * tan4
+	  - tan6) / 40320.e0;
+
+	y = _falseNorthing + t1 + pow(dlam, 2.e0) * t2 + pow(dlam, 4.e0) * t3
+	  + pow(dlam, 6.e0) * t4 + pow(dlam, 8.e0) * t5;
+
+
+	t6 = sn * cl * _scale;
+	t7 = sn * c3 * _scale * (1.e0 - tan2 + eta) /6.e0;
+	t8 = sn * c5 * _scale * (5.e0 - 18.e0 * tan2 + tan4 + 14.e0 * eta - 58.e0
+	  * tan2 * eta + 13.e0 * eta2 + 4.e0 * eta3 - 64.e0 * tan2 * eta2 - 24.e0
+	  * tan2 * eta3) / 120.e0;
+	t9 = sn * c7 * _scale * (61.e0 - 479.e0 * tan2 + 179.e0 * tan4 - tan6)
+	  / 5040.e0;
+
+	x = _falseEasting + dlam * t6 + pow(dlam, 3.e0) * t7 + pow(dlam, 5.e0)
+	  * t8 + pow(dlam, 7.e0) * t9;
+
+	return QPointF(x, y);
+}
+
+Coordinates TransverseMercator::xy2ll(const QPointF &p) const
+{
+	double cl;
+	double de;
+	double dlam;
+	double eta, eta2, eta3, eta4;
+	double ftphi;
+	double sn;
+	double sr;
+	double t, tan2, tan4;
+	double t10, t11, t12, t13, t14, t15, t16, t17;
+	double tmd, tmdo;
+	double lat, lon;
+
+
+	tmdo = SPHTMD(_latitudeOrigin);
+	tmd = tmdo + (p.y() - _falseNorthing) / _scale;
+
+	sr = SPHSR(0.e0);
+	ftphi = tmd / sr;
+
+	for (int i = 0; i < 5 ; i++) {
+		t10 = SPHTMD(ftphi);
+		sr = SPHSR(ftphi);
+		ftphi = ftphi + (tmd - t10) / sr;
+	}
+
+	sr = SPHSR(ftphi);
+	sn = SPHSN(ftphi);
+
+	cl = cos(ftphi);
+
+	t = tan(ftphi);
+	tan2 = t * t;
+	tan4 = tan2 * tan2;
+	eta = _ebs * pow(cl, 2);
+	eta2 = eta * eta;
+	eta3 = eta2 * eta;
+	eta4 = eta3 * eta;
+	de = p.x() - _falseEasting;
+	if (fabs(de) < 0.0001)
+		de = 0.0;
+
+	t10 = t / (2.e0 * sr * sn * pow(_scale, 2));
+	t11 = t * (5.e0  + 3.e0 * tan2 + eta - 4.e0 * pow(eta, 2) - 9.e0 * tan2
+	  * eta) / (24.e0 * sr * pow(sn, 3) * pow(_scale, 4));
+	t12 = t * (61.e0 + 90.e0 * tan2 + 46.e0 * eta + 45.E0 * tan4 - 252.e0 * tan2
+	  * eta - 3.e0 * eta2 + 100.e0 * eta3 - 66.e0 * tan2 * eta2 - 90.e0 * tan4
+	  * eta + 88.e0 * eta4 + 225.e0 * tan4 * eta2 + 84.e0 * tan2 * eta3 - 192.e0
+	  * tan2 * eta4) / (720.e0 * sr * pow(sn, 5) * pow(_scale, 6));
+	t13 = t * (1385.e0 + 3633.e0 * tan2 + 4095.e0 * tan4 + 1575.e0 * pow(t,6))
+	  / (40320.e0 * sr * pow(sn, 7) * pow(_scale, 8));
+	lat = ftphi - pow(de, 2) * t10 + pow(de, 4) * t11 - pow(de, 6) * t12
+	  + pow(de, 8) * t13;
+
+	t14 = 1.e0 / (sn * cl * _scale);
+	t15 = (1.e0 + 2.e0 * tan2 + eta) / (6.e0 * pow(sn, 3) * cl * pow(_scale, 3));
+	t16 = (5.e0 + 6.e0 * eta + 28.e0 * tan2 - 3.e0 * eta2 + 8.e0 * tan2 * eta
+	  + 24.e0 * tan4 - 4.e0 * eta3 + 4.e0 * tan2 * eta2 + 24.e0 * tan2 * eta3)
+	  / (120.e0 * pow(sn, 5) * cl * pow(_scale, 5));
+	t17 = (61.e0 +  662.e0 * tan2 + 1320.e0 * tan4 + 720.e0 * pow(t,6))
+	  / (5040.e0 * pow(sn, 7) * cl * pow(_scale, 7));
+
+	dlam = de * t14 - pow(de, 3) * t15 + pow(de, 5) * t16 - pow(de, 7) * t17;
+
+	lon = _longitudeOrigin + dlam;
+	while (lat > deg2rad(90.0)) {
+		lat = M_PI - lat;
+		lon += M_PI;
+		if (lon > M_PI)
+			lon -= (2 * M_PI);
+	}
+
+	while (lat < deg2rad(-90.0)) {
+		lat = - (lat + M_PI);
+		lon += M_PI;
+		if (lon > M_PI)
+			lon -= (2 * M_PI);
+	}
+
+	if (lon > (2 * M_PI))
+		lon -= (2 * M_PI);
+	if (lon < -M_PI)
+		lon += (2 * M_PI);
+
+	return Coordinates(rad2deg(lon), rad2deg(lat));
+}

src/map/transversemercator.h

@@ -0,0 +1,30 @@
+#ifndef TRANSVERSEMERCATOR_H
+#define TRANSVERSEMERCATOR_H
+
+#include "projection.h"
+#include "ellipsoid.h"
+
+class TransverseMercator : public Projection
+{
+public:
+	TransverseMercator(const Ellipsoid &ellipsoid, double latitudeOrigin,
+	  double longitudeOrigin, double scale, double falseEasting,
+	  double falseNorthing);
+
+	virtual QPointF ll2xy(const Coordinates &c) const;
+	virtual Coordinates xy2ll(const QPointF &p) const;
+
+private:
+	Ellipsoid _e;
+	double _longitudeOrigin;
+	double _latitudeOrigin;
+	double _scale;
+	double _falseEasting;
+	double _falseNorthing;
+
+	double _es;
+	double _ebs;
+	double _ap, _bp, _cp, _dp, _ep;
+};
+
+#endif // TRANSVERSEMERCATOR_H

src/map/utm.cpp

@@ -0,0 +1,28 @@
+#include "ellipsoid.h"
+#include "utm.h"
+
+UTM::UTM(const Ellipsoid &ellipsoid, int zone)
+  : _tm(ellipsoid, 0, (qAbs(zone) - 1)*6 - 180 + 3, 0.9996, 500000,
+  zone < 0 ? 10000000 : 0)
+{
+}
+
+int UTM::zone(const Coordinates &c)
+{
+	int zone = int((c.lon() + 180)/6) + 1;
+
+	if (c.lat() >= 56.0 && c.lat() < 64.0 && c.lon() >= 3.0 && c.lon() < 12.0)
+		zone = 32;
+	if (c.lat() >= 72.0 && c.lat() < 84.0) {
+		if (c.lon() >= 0.0  && c.lon() <  9.0)
+			zone = 31;
+		else if (c.lon() >= 9.0  && c.lon() < 21.0)
+			zone = 33;
+		else if (c.lon() >= 21.0 && c.lon() < 33.0)
+			zone = 35;
+		else if (c.lon() >= 33.0 && c.lon() < 42.0)
+			zone = 37;
+	}
+
+	return zone;
+}

src/map/utm.h

@@ -0,0 +1,23 @@
+#ifndef UTM_H
+#define UTM_H
+
+#include "projection.h"
+#include "transversemercator.h"
+
+class UTM : public Projection
+{
+public:
+	UTM(const Ellipsoid &ellipsoid, int zone);
+
+	virtual QPointF ll2xy(const Coordinates &c) const
+	  {return _tm.ll2xy(c);}
+	virtual Coordinates xy2ll(const QPointF &p) const
+	  {return _tm.xy2ll(p);}
+
+	static int zone(const Coordinates &c);
+
+private:
+	TransverseMercator _tm;
+};
+
+#endif // UTM_H