Formats minimally release source files based on former clang-format

This commit is contained in:
torsten committed 2026-10-14 13:28:01 +00:00
1 parent b662e4daf9
commit 5644914fe3
387 files changed
+37323 -38074

No files matched your search

@@ -5,60 +5,70 @@
#include <cstring>
#include <string>
int main(int argc, char** argv)
int main(int argc, char **argv)
{
if (argc < 3 || argc > 5)
{
fprintf(stderr, "Usage: %s <lon_degree> <lat_degree> [<precision>]\n", argv[0]);
fprintf(stderr, "Usage: %s <lon_rad> <lat_rad> -r [<precision>]\n", argv[0]);
return -1;
}
if (argc < 3 || argc > 5)
{
fprintf(stderr, "Usage: %s <lon_degree> <lat_degree> [<precision>]\n", argv[0]);
fprintf(stderr, "Usage: %s <lon_rad> <lat_rad> -r [<precision>]\n", argv[0]);
return -1;
}
bool lonLatInRad = false;
double lon = atof(argv[1]);
double lat = atof(argv[2]);
int prec = 5;
if (argc >= 4)
bool lonLatInRad = false;
double lon = atof(argv[1]);
double lat = atof(argv[2]);
int prec = 5;
if (argc >= 4)
{
int precArgId = -1;
if (strcmp(argv[3], "-r") == 0)
{
int precArgId = -1;
if (strcmp(argv[3], "-r") == 0)
{
lonLatInRad = true;
if (argc == 5)
precArgId = 4;
}
else
precArgId = 3;
if (precArgId > 0)
prec = atoi(argv[precArgId]);
lonLatInRad = true;
if (argc == 5)
precArgId = 4;
}
else
precArgId = 3;
if (precArgId > 0)
prec = atoi(argv[precArgId]);
}
std::string mgrs;
std::string mgrs;
int zone;
bool northp;
double x, y;
try
{
const double latDeg = lonLatInRad ? lat * 180 / M_PI : lat;
const double lonDeg = lonLatInRad ? lon * 180 / M_PI : lon;
GeographicLib::UTMUPS::Forward(latDeg, lonDeg, zone, northp, x, y);
GeographicLib::MGRS::Forward(zone, northp, x, y, prec, mgrs);
}
catch (...)
{
fprintf(stderr, "Error converting %9.6f, %9.6f to MGRS coords\n", lat, lon);
return -2;
}
std::string part1, part2, part3, part4;
part1 = mgrs.substr(0, 3);
part2 = mgrs.substr(3, 2);
if (prec > 0)
{
part3 = mgrs.substr(5, prec);
part4 = mgrs.substr(5 + prec, prec);
}
fprintf(stdout, "%13.10f, %13.10f = %s %s %s %s (UTM: %d %.2f, %.2f %c)\n", lon, lat, part1.c_str(), part2.c_str(),
part3.c_str(), part4.c_str(), zone, x, y, northp ? 'N' : 'S');
return 0;
int zone;
bool northp;
double x, y;
try
{
const double latDeg = lonLatInRad ? lat * 180 / M_PI : lat;
const double lonDeg = lonLatInRad ? lon * 180 / M_PI : lon;
GeographicLib::UTMUPS::Forward(latDeg, lonDeg, zone, northp, x, y);
GeographicLib::MGRS::Forward(zone, northp, x, y, prec, mgrs);
}
catch (...)
{
fprintf(stderr, "Error converting %9.6f, %9.6f to MGRS coords\n", lat, lon);
return -2;
}
std::string part1, part2, part3, part4;
part1 = mgrs.substr(0, 3);
part2 = mgrs.substr(3, 2);
if (prec > 0)
{
part3 = mgrs.substr(5, prec);
part4 = mgrs.substr(5 + prec, prec);
}
fprintf(stdout,
"%13.10f, %13.10f = %s %s %s %s (UTM: %d %.2f, %.2f %c)\n",
lon,
lat,
part1.c_str(),
part2.c_str(),
part3.c_str(),
part4.c_str(),
zone,
x,
y,
northp ? 'N' : 'S');
return 0;
}
@@ -15,110 +15,108 @@
namespace LtsCoordTrans
{
static long s_conversion_counter_MGRS_Forward = 0;
static long s_conversion_counter_MGRS_Reverse = 0;
static long s_conversion_counter_MGRS_Forward = 0;
static long s_conversion_counter_MGRS_Reverse = 0;
static long s_conversion_counter_WGS84_Forward = 0;
static long s_conversion_counter_WGS84_Reverse = 0;
static long s_conversion_counter_WGS84_Forward = 0;
static long s_conversion_counter_WGS84_Reverse = 0;
static long s_conversion_counter_UTMUPS_Forward = 0;
static long s_conversion_counter_UTMUPS_Reverse = 0;
static long s_conversion_counter_UTMUPS_Forward = 0;
static long s_conversion_counter_UTMUPS_Reverse = 0;
inline void incrementCounter(long& counterRef)
{
inline void incrementCounter(long &counterRef)
{
#ifdef LTS_DEBUG
++counterRef;
#endif
}
}
static inline std::string cleanupMgrsString(const QString& in)
{
static inline std::string cleanupMgrsString(const QString &in)
{
const QByteArray ba(in.toLatin1());
std::string ret;
ret.reserve(ba.size());
for (const char c : ba)
{
if (c != ' ')
ret += c;
if (c != ' ')
ret += c;
}
return ret;
}
}
QString UtmCoordinate::mgrs(int prec, bool withSpaces) const
{
QString UtmCoordinate::mgrs(int prec, bool withSpaces) const
{
if (prec < 0)
prec = 0;
prec = 0;
if (prec > 11)
prec = 11;
prec = 11;
std::string mgrs;
try
{
GeographicLib::MGRS::Forward(zone, northp, x, y, prec, mgrs);
incrementCounter(s_conversion_counter_MGRS_Forward);
GeographicLib::MGRS::Forward(zone, northp, x, y, prec, mgrs);
incrementCounter(s_conversion_counter_MGRS_Forward);
}
catch (const std::exception& e)
catch (const std::exception &e)
{
fprintf(stderr, "Error while calculating mgrs from utm %d, %9.6f, %9.6f: %s\n", zone, x, y, e.what());
mgrs.clear();
fprintf(stderr, "Error while calculating mgrs from utm %d, %9.6f, %9.6f: %s\n", zone, x, y, e.what());
mgrs.clear();
}
QString ret;
if (withSpaces && mgrs.size() == static_cast<size_t>(5 + 2 * prec))
{
const char* ptr = mgrs.c_str();
const char *ptr = mgrs.c_str();
ret = QString::fromLatin1(ptr, 3) + QLatin1Char(' ') + QString::fromLatin1(ptr + 3, 2);
if (prec > 0)
{
ret += QLatin1Char(' ') + QString::fromLatin1(ptr + 5, prec) + QLatin1Char(' ') +
QString::fromLatin1(ptr + 5 + prec, prec);
}
ret = QString::fromLatin1(ptr, 3) + QLatin1Char(' ') + QString::fromLatin1(ptr + 3, 2);
if (prec > 0)
{
ret += QLatin1Char(' ') + QString::fromLatin1(ptr + 5, prec) + QLatin1Char(' ') + QString::fromLatin1(ptr + 5 + prec, prec);
}
}
else
ret = QString::fromLatin1(mgrs.c_str(), mgrs.size());
ret = QString::fromLatin1(mgrs.c_str(), mgrs.size());
return ret;
}
}
QPointF UtmCoordinate::toPoint() const
{
QPointF UtmCoordinate::toPoint() const
{
return {x, y};
}
}
QPointF UtmCoordinate::geographic(double offsetX, double offsetY) const
{
QPointF UtmCoordinate::geographic(double offsetX, double offsetY) const
{
QPointF ret;
try
{
GeographicLib::UTMUPS::Reverse(zone, northp, x + offsetX, y + offsetY, ret.ry(), ret.rx());
incrementCounter(s_conversion_counter_UTMUPS_Reverse);
GeographicLib::UTMUPS::Reverse(zone, northp, x + offsetX, y + offsetY, ret.ry(), ret.rx());
incrementCounter(s_conversion_counter_UTMUPS_Reverse);
}
catch (const std::exception& e)
catch (const std::exception &e)
{
fprintf(stderr, "Error while calculating geographic from utm %d, %9.6f, %9.6f: %s\n", zone, x + offsetX,
y + offsetY, e.what());
ret = QPointF();
fprintf(stderr, "Error while calculating geographic from utm %d, %9.6f, %9.6f: %s\n", zone, x + offsetX, y + offsetY, e.what());
ret = QPointF();
}
return ret * deg2rad();
}
}
QPointF UtmCoordinate::geographic(const QPointF& offset) const
{
QPointF UtmCoordinate::geographic(const QPointF &offset) const
{
return geographic(offset.x(), offset.y());
}
}
QPointF UtmCoordinate::relativeTo(const UtmCoordinate& other) const
{
QPointF UtmCoordinate::relativeTo(const UtmCoordinate &other) const
{
if (zone == other.zone)
return QPointF(x - other.x, y - other.y);
return QPointF(x - other.x, y - other.y);
UtmCoordinate otherInMyZone = fromGeographic(other.geographic(), zone);
return QPointF(x - otherInMyZone.x, y - otherInMyZone.y);
}
}
UtmCoordinate UtmCoordinate::fromGeographic(double lon, double lat, int setZone)
{
UtmCoordinate UtmCoordinate::fromGeographic(double lon, double lat, int setZone)
{
lon *= rad2deg();
lat *= rad2deg();
@@ -127,81 +125,81 @@ UtmCoordinate UtmCoordinate::fromGeographic(double lon, double lat, int setZone)
try
{
GeographicLib::UTMUPS::Forward(lat, lon, ret.zone, ret.northp, ret.x, ret.y, setZone);
incrementCounter(s_conversion_counter_UTMUPS_Forward);
GeographicLib::UTMUPS::Forward(lat, lon, ret.zone, ret.northp, ret.x, ret.y, setZone);
incrementCounter(s_conversion_counter_UTMUPS_Forward);
}
catch (const std::exception& e)
catch (const std::exception &e)
{
fprintf(stderr, "Error while calculating mgrs base point from %9.6f, %9.6f: %s\n", lat, lon, e.what());
ret = UtmCoordinate();
fprintf(stderr, "Error while calculating mgrs base point from %9.6f, %9.6f: %s\n", lat, lon, e.what());
ret = UtmCoordinate();
}
return ret;
}
}
UtmCoordinate UtmCoordinate::fromGeographic(const QPointF& lonLat, int setZone)
{
UtmCoordinate UtmCoordinate::fromGeographic(const QPointF &lonLat, int setZone)
{
return fromGeographic(lonLat.x(), lonLat.y(), setZone);
}
}
UtmCoordinate UtmCoordinate::fromMgrs(const QString& mgrs)
{
UtmCoordinate UtmCoordinate::fromMgrs(const QString &mgrs)
{
UtmCoordinate utm;
try
{
int prec;
int prec;
GeographicLib::MGRS::Reverse(cleanupMgrsString(mgrs), utm.zone, utm.northp, utm.x, utm.y, prec, true);
incrementCounter(s_conversion_counter_MGRS_Reverse);
GeographicLib::MGRS::Reverse(cleanupMgrsString(mgrs), utm.zone, utm.northp, utm.x, utm.y, prec, true);
incrementCounter(s_conversion_counter_MGRS_Reverse);
}
catch (const std::exception& e)
catch (const std::exception &e)
{
fprintf(stderr, "Error while converting mgrs coordinate %s to utm: %s\n", qPrintable(mgrs), e.what());
utm = UtmCoordinate();
fprintf(stderr, "Error while converting mgrs coordinate %s to utm: %s\n", qPrintable(mgrs), e.what());
utm = UtmCoordinate();
}
return utm;
}
}
QString mgrsFromGeographic(double lon, double lat, int prec, bool withSpaces)
{
QString mgrsFromGeographic(double lon, double lat, int prec, bool withSpaces)
{
return UtmCoordinate::fromGeographic(lon, lat, -1).mgrs(prec, withSpaces);
}
}
QPointF geographicFromMgrs(const QString& mgrs)
{
QPointF geographicFromMgrs(const QString &mgrs)
{
return UtmCoordinate::fromMgrs(mgrs).geographic();
}
}
QVector<UtmCoordinate>& staticDefaultSquaresHelper()
{
QVector<UtmCoordinate> &staticDefaultSquaresHelper()
{
static QVector<UtmCoordinate> s_defaultMgrsSquares;
return s_defaultMgrsSquares;
}
}
UtmCoordinate& staticPreferedMgrsSquareHelper()
{
UtmCoordinate &staticPreferedMgrsSquareHelper()
{
static UtmCoordinate s_preferedMgrsSquare;
return s_preferedMgrsSquare;
}
}
QVector<UtmCoordinate>& staticMgrsSquaresWithOffsetsHelper()
{
QVector<UtmCoordinate> &staticMgrsSquaresWithOffsetsHelper()
{
static QVector<UtmCoordinate> s_mgrsSquaresWithOffsets;
return s_mgrsSquaresWithOffsets;
}
}
QRectF addMarginToArea(const QRectF& rect_LatLon_radiant, const QSize& marginMeter)
{
QRectF addMarginToArea(const QRectF &rect_LatLon_radiant, const QSize &marginMeter)
{
double lonMin, lonMax, latMin, latMmax;
rect_LatLon_radiant.normalized().getCoords(&lonMin, &latMin, &lonMax, &latMmax);
LtsCoordTrans::UtmCoordinate basePoint;
{
const QPointF centerRad = rect_LatLon_radiant.center();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(centerRad.x(), centerRad.y(), -1);
mgrs += QStringLiteral("00000000000000");
const QPointF centerRad = rect_LatLon_radiant.center();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(centerRad.x(), centerRad.y(), -1);
mgrs += QStringLiteral("00000000000000");
basePoint = LtsCoordTrans::UtmCoordinate::fromMgrs(mgrs);
basePoint = LtsCoordTrans::UtmCoordinate::fromMgrs(mgrs);
}
const UtmCoordinate lowerLeft(UtmCoordinate::fromGeographic(lonMin, latMin, basePoint.zone));
@@ -215,27 +213,26 @@ QRectF addMarginToArea(const QRectF& rect_LatLon_radiant, const QSize& marginMet
QRectF res = QRectF(topLeft, bottomRight);
return res;
}
}
QVector<UtmCoordinate> getMgrsSquares(const QRectF& rect, bool setAsDefaultSquares, bool setAsPreferedSquare,
bool setAsSquareWithMargin)
{
QVector<UtmCoordinate> getMgrsSquares(const QRectF &rect, bool setAsDefaultSquares, bool setAsPreferedSquare, bool setAsSquareWithMargin)
{
QVector<UtmCoordinate> ret = getMgrsSquaresInternal(rect);
if (setAsDefaultSquares)
staticDefaultSquaresHelper() = ret;
staticDefaultSquaresHelper() = ret;
if (setAsPreferedSquare)
staticPreferedMgrsSquareHelper() = LtsCoordTrans::UtmCoordinate::fromGeographic(rect.center());
staticPreferedMgrsSquareHelper() = LtsCoordTrans::UtmCoordinate::fromGeographic(rect.center());
if (setAsSquareWithMargin)
staticMgrsSquaresWithOffsetsHelper() = ret;
staticMgrsSquaresWithOffsetsHelper() = ret;
return ret;
}
}
QVector<UtmCoordinate> getMgrsSquaresInternal(const QRectF& rect)
{
QVector<UtmCoordinate> getMgrsSquaresInternal(const QRectF &rect)
{
QVector<UtmCoordinate> ret;
QVector<QString> tmpMgrsSquares;
@@ -244,19 +241,19 @@ QVector<UtmCoordinate> getMgrsSquaresInternal(const QRectF& rect)
bool withInSingleUtmSquare = true;
{
const UtmCoordinate upperRight(UtmCoordinate::fromGeographic(lonMax, latMmax));
const UtmCoordinate lowerLeft(UtmCoordinate::fromGeographic(lonMin, latMin));
withInSingleUtmSquare = upperRight.zone == lowerLeft.zone;
const UtmCoordinate upperRight(UtmCoordinate::fromGeographic(lonMax, latMmax));
const UtmCoordinate lowerLeft(UtmCoordinate::fromGeographic(lonMin, latMin));
withInSingleUtmSquare = upperRight.zone == lowerLeft.zone;
}
LtsCoordTrans::UtmCoordinate basePoint;
{
QPointF centerRad = rect.center();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(centerRad.x(), centerRad.y(), -1);
mgrs += QStringLiteral("00000000000000");
QPointF centerRad = rect.center();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(centerRad.x(), centerRad.y(), -1);
mgrs += QStringLiteral("00000000000000");
basePoint = LtsCoordTrans::UtmCoordinate::fromMgrs(mgrs);
basePoint = LtsCoordTrans::UtmCoordinate::fromMgrs(mgrs);
}
const UtmCoordinate upperRight(UtmCoordinate::fromGeographic(lonMax, latMmax, basePoint.zone));
@@ -268,180 +265,173 @@ QVector<UtmCoordinate> getMgrsSquaresInternal(const QRectF& rect)
const int increment = withInSingleUtmSquare ? 10000 : 1000;
for (double x = 0; x <= maxX + increment; x += increment)
{
const double xOfs = std::min(x, maxX);
for (double y = 0; y <= maxY + increment; y += increment)
const double xOfs = std::min(x, maxX);
for (double y = 0; y <= maxY + increment; y += increment)
{
const double yOfs = std::min(y, maxY);
const UtmCoordinate utm(UtmCoordinate::fromGeographic(lowerLeft.geographic(xOfs, yOfs)));
const QString mgrs(utm.mgrs(0));
if (!tmpMgrsSquares.contains(mgrs))
{
const double yOfs = std::min(y, maxY);
const UtmCoordinate utm(UtmCoordinate::fromGeographic(lowerLeft.geographic(xOfs, yOfs)));
const QString mgrs(utm.mgrs(0));
if (!tmpMgrsSquares.contains(mgrs))
{
tmpMgrsSquares += mgrs;
ret += utm;
}
tmpMgrsSquares += mgrs;
ret += utm;
}
}
}
return ret;
}
}
QStringList getMgrsSurroundingSquares(const QRectF& geoRect, const QSize& offsetMeter)
{
QStringList getMgrsSurroundingSquares(const QRectF &geoRect, const QSize &offsetMeter)
{
const QVector<UtmCoordinate> mainUtms = getMgrsSquaresInternal(geoRect);
QStringList mainSquares;
mainSquares.reserve(mainUtms.count());
for (const auto& utm : mainUtms)
mainSquares.append(utm.mgrs(0));
for (const auto &utm : mainUtms)
mainSquares.append(utm.mgrs(0));
const QRectF rectWithOffset = addMarginToArea(geoRect, offsetMeter);
QVector<UtmCoordinate> mainUtmsWithOffset = getMgrsSquaresInternal(rectWithOffset);
QStringList mainSquaresWithOffset;
mainSquaresWithOffset.reserve(mainUtmsWithOffset.count());
for (const auto& utm : std::as_const(mainUtmsWithOffset))
mainSquaresWithOffset.append(utm.mgrs(0));
for (const auto &utm : std::as_const(mainUtmsWithOffset))
mainSquaresWithOffset.append(utm.mgrs(0));
QStringList surroundingSquares;
surroundingSquares.reserve(mainSquaresWithOffset.count());
for (const auto& mgrs0 : mainSquaresWithOffset)
for (const auto &mgrs0 : mainSquaresWithOffset)
{
if (!mainSquares.contains(mgrs0))
surroundingSquares.append(mgrs0);
if (!mainSquares.contains(mgrs0))
surroundingSquares.append(mgrs0);
}
return surroundingSquares;
}
}
QVector<UtmCoordinate> defaultMgrsSquareWithOffsets()
{
QVector<UtmCoordinate> defaultMgrsSquareWithOffsets()
{
return staticMgrsSquaresWithOffsetsHelper();
}
}
void setDefaultMgrsSquares(const QVector<QString>& squares)
{
void setDefaultMgrsSquares(const QVector<QString> &squares)
{
QVector<UtmCoordinate> coords;
coords.reserve(squares.size());
for (const QString& s : squares)
coords += UtmCoordinate::fromMgrs(s + QStringLiteral("00000000000000"));
for (const QString &s : squares)
coords += UtmCoordinate::fromMgrs(s + QStringLiteral("00000000000000"));
staticDefaultSquaresHelper() = coords;
}
}
QVector<UtmCoordinate> defaultMgrsSquares()
{
QVector<UtmCoordinate> defaultMgrsSquares()
{
return staticDefaultSquaresHelper();
}
}
UtmCoordinate preferedMgrsSquare()
{
UtmCoordinate preferedMgrsSquare()
{
return staticPreferedMgrsSquareHelper();
}
}
bool lonLatAltToGeocentric(double lon, double lat, double altitude, double& xOut, double& yOut, double& zOut)
{
bool lonLatAltToGeocentric(double lon, double lat, double altitude, double &xOut, double &yOut, double &zOut)
{
lon *= rad2deg();
lat *= rad2deg();
try
{
GeographicLib::Geocentric::WGS84().Forward(lat, lon, altitude, xOut, yOut, zOut);
incrementCounter(s_conversion_counter_WGS84_Forward);
GeographicLib::Geocentric::WGS84().Forward(lat, lon, altitude, xOut, yOut, zOut);
incrementCounter(s_conversion_counter_WGS84_Forward);
}
catch (...)
{
xOut = 0;
yOut = 0;
zOut = 0;
return false;
xOut = 0;
yOut = 0;
zOut = 0;
return false;
}
return true;
}
}
bool geocentric2LonLatAlt(double x, double y, double z, double& lon, double& lat, double& altitude)
{
bool geocentric2LonLatAlt(double x, double y, double z, double &lon, double &lat, double &altitude)
{
try
{
GeographicLib::Geocentric::WGS84().Reverse(x, y, z, lat, lon, altitude);
incrementCounter(s_conversion_counter_WGS84_Reverse);
GeographicLib::Geocentric::WGS84().Reverse(x, y, z, lat, lon, altitude);
incrementCounter(s_conversion_counter_WGS84_Reverse);
}
catch (...)
{
lon = 0;
lat = 0;
altitude = 0;
return false;
lon = 0;
lat = 0;
altitude = 0;
return false;
}
lon *= deg2rad();
lat *= deg2rad();
return true;
}
}
double distance(const QPointF& p1, const QPointF& p2)
{
double distance(const QPointF &p1, const QPointF &p2)
{
return distance(p1.x(), p1.y(), p2.x(), p2.y());
}
}
double squareDistance(const QPointF& p1, const QPointF& p2)
{
double squareDistance(const QPointF &p1, const QPointF &p2)
{
return squareDistance(p1.x(), p1.y(), p2.x(), p2.y());
}
}
std::ostream& operator<<(std::ostream& stream, const UtmCoordinate& coord)
{
std::ostream &operator<<(std::ostream &stream, const UtmCoordinate &coord)
{
stream << "UtmCoordinate(" << std::setprecision(8) << coord.x << "#" << std::setprecision(8) << coord.y
<< " zone=" << coord.zone << ")";
stream << "UtmCoordinate(" << std::setprecision(8) << coord.x << "#" << std::setprecision(8) << coord.y << " zone=" << coord.zone << ")";
return stream;
}
}
void dumpConversionCounter()
{
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_MGRS_Forward : - mgrs : %ld\n",
s_conversion_counter_MGRS_Forward);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_MGRS_Reverse - fromMgrs : %ld\n",
s_conversion_counter_MGRS_Reverse);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_WGS84_Forward - lonLatAltToGeocentric : %ld\n",
s_conversion_counter_WGS84_Forward);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_WGS84_Reverse - geocentric2LonLatAlt : %ld\n",
s_conversion_counter_WGS84_Reverse);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_UTMUPS_Forward - fromGeographic : %ld\n",
s_conversion_counter_UTMUPS_Forward);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_UTMUPS_Reverse - geographic : %ld\n",
s_conversion_counter_UTMUPS_Reverse);
}
void dumpConversionCounter()
{
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_MGRS_Forward : - mgrs : %ld\n", s_conversion_counter_MGRS_Forward);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_MGRS_Reverse - fromMgrs : %ld\n", s_conversion_counter_MGRS_Reverse);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_WGS84_Forward - lonLatAltToGeocentric : %ld\n", s_conversion_counter_WGS84_Forward);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_WGS84_Reverse - geocentric2LonLatAlt : %ld\n", s_conversion_counter_WGS84_Reverse);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_UTMUPS_Forward - fromGeographic : %ld\n", s_conversion_counter_UTMUPS_Forward);
fprintf(stderr, "LtsCoordTrans: s_conversion_counter_UTMUPS_Reverse - geographic : %ld\n", s_conversion_counter_UTMUPS_Reverse);
}
long getConversionCounter_MGRS_Forward()
{
long getConversionCounter_MGRS_Forward()
{
return s_conversion_counter_MGRS_Forward;
}
}
long getConversionCounter_MGRS_Reverse()
{
long getConversionCounter_MGRS_Reverse()
{
return s_conversion_counter_MGRS_Reverse;
}
}
long getConversionCounter_WGS84_Forward()
{
long getConversionCounter_WGS84_Forward()
{
return s_conversion_counter_WGS84_Forward;
}
}
long getConversionCounter_WGS84_Reverse()
{
long getConversionCounter_WGS84_Reverse()
{
return s_conversion_counter_WGS84_Reverse;
}
}
long getConversionCounter_UTMUPS_Forward()
{
long getConversionCounter_UTMUPS_Forward()
{
return s_conversion_counter_UTMUPS_Forward;
}
}
long getConversionCounter_UTMUPS_Reverse()
{
long getConversionCounter_UTMUPS_Reverse()
{
return s_conversion_counter_UTMUPS_Reverse;
}
}
} // namespace LtsCoordTrans
@@ -14,23 +14,23 @@ class QString;
namespace LtsCoordTrans
{
inline Q_CONSTEXPR double pi()
{
inline Q_CONSTEXPR double pi()
{
return M_PI;
}
}
inline Q_CONSTEXPR double deg2rad()
{
inline Q_CONSTEXPR double deg2rad()
{
return pi() / 180.;
}
}
inline Q_CONSTEXPR double rad2deg()
{
inline Q_CONSTEXPR double rad2deg()
{
return 1. / deg2rad();
}
}
struct LTSCOORDTRANS_EXPORT UtmCoordinate
{
struct LTSCOORDTRANS_EXPORT UtmCoordinate
{
int zone = -1;
bool northp = true;
double x = 0.;
@@ -38,152 +38,146 @@ struct LTSCOORDTRANS_EXPORT UtmCoordinate
UtmCoordinate() = default;
UtmCoordinate(int zone_, double x_, double y_, bool northp_ = true) : zone(zone_), northp(northp_), x(x_), y(y_) {}
bool isValid() const
UtmCoordinate(int zone_, double x_, double y_, bool northp_ = true)
: zone(zone_)
, northp(northp_)
, x(x_)
, y(y_)
{
return zone > 0 && zone <= 60;
}
bool isValid() const { return zone > 0 && zone <= 60; }
QString mgrs(int prec = 5, bool withSpaces = true) const;
QPointF toPoint() const;
QPointF geographic(double offsetX = 0., double offsetY = 0.) const;
QPointF geographic(const QPointF& offset) const;
QPointF geographic(const QPointF &offset) const;
QPointF relativeTo(const UtmCoordinate& other) const;
QPointF relativeTo(const UtmCoordinate &other) const;
static UtmCoordinate fromGeographic(double lon, double lat, int setZone = -1);
static UtmCoordinate fromGeographic(const QPointF& lonLat, int setZone = -1);
static UtmCoordinate fromGeographic(const QPointF &lonLat, int setZone = -1);
static UtmCoordinate fromMgrs(const QString& mgrs);
};
static UtmCoordinate fromMgrs(const QString &mgrs);
};
LTSCOORDTRANS_EXPORT QString mgrsFromGeographic(double lon, double lat, int prec = 5, bool withSpaces = true);
LTSCOORDTRANS_EXPORT QString mgrsFromGeographic(double lon, double lat, int prec = 5, bool withSpaces = true);
LTSCOORDTRANS_EXPORT QPointF geographicFromMgrs(const QString& mgrs);
LTSCOORDTRANS_EXPORT QPointF geographicFromMgrs(const QString &mgrs);
LTSCOORDTRANS_EXPORT QRectF addMarginToArea(const QRectF& rect_LatLon_radiant, const QSize& marginMeter);
LTSCOORDTRANS_EXPORT QRectF addMarginToArea(const QRectF &rect_LatLon_radiant, const QSize &marginMeter);
LTSCOORDTRANS_EXPORT QVector<UtmCoordinate> getMgrsSquares(const QRectF& rect, bool setAsDefaultSquares,
bool setAsPreferedSquare,
bool setAsSquareWithMargin = false);
LTSCOORDTRANS_EXPORT QVector<UtmCoordinate> getMgrsSquares(const QRectF &rect, bool setAsDefaultSquares, bool setAsPreferedSquare, bool setAsSquareWithMargin = false);
QVector<UtmCoordinate> getMgrsSquaresInternal(const QRectF& rect);
QVector<UtmCoordinate> getMgrsSquaresInternal(const QRectF &rect);
QStringList getMgrsSurroundingSquares(const QRectF& geoRect, const QSize& offsetMeter);
QStringList getMgrsSurroundingSquares(const QRectF &geoRect, const QSize &offsetMeter);
LTSCOORDTRANS_EXPORT QVector<UtmCoordinate> defaultMgrsSquareWithOffsets();
LTSCOORDTRANS_EXPORT QVector<UtmCoordinate> defaultMgrsSquareWithOffsets();
LTSCOORDTRANS_EXPORT void setDefaultMgrsSquares(const QVector<QString>& squares);
LTSCOORDTRANS_EXPORT void setDefaultMgrsSquares(const QVector<QString> &squares);
LTSCOORDTRANS_EXPORT QVector<UtmCoordinate> defaultMgrsSquares();
LTSCOORDTRANS_EXPORT QVector<UtmCoordinate> defaultMgrsSquares();
LTSCOORDTRANS_EXPORT UtmCoordinate preferedMgrsSquare();
LTSCOORDTRANS_EXPORT UtmCoordinate preferedMgrsSquare();
LTSCOORDTRANS_EXPORT bool lonLatAltToGeocentric(double lon, double lat, double altitude, double& xOut, double& yOut,
double& zOut);
LTSCOORDTRANS_EXPORT bool lonLatAltToGeocentric(double lon, double lat, double altitude, double &xOut, double &yOut, double &zOut);
LTSCOORDTRANS_EXPORT bool geocentric2LonLatAlt(double x, double y, double z, double& lon, double& lat,
double& altitude);
LTSCOORDTRANS_EXPORT bool geocentric2LonLatAlt(double x, double y, double z, double &lon, double &lat, double &altitude);
inline double squareDistance(const UtmCoordinate& p1, const UtmCoordinate& p2)
{
inline double squareDistance(const UtmCoordinate &p1, const UtmCoordinate &p2)
{
if (p1.zone != p2.zone)
{
Q_ASSERT(false);
return std::nan("");
Q_ASSERT(false);
return std::nan("");
}
return std::pow(p1.x - p2.x, 2) + std::pow(p1.y - p2.y, 2);
}
}
LTSCOORDTRANS_EXPORT double squareDistance(const QPointF& p1, const QPointF& p2);
LTSCOORDTRANS_EXPORT double squareDistance(const QPointF &p1, const QPointF &p2);
inline double squareDistance(const double lon1, const double lat1, const double lon2, const double lat2)
{
inline double squareDistance(const double lon1, const double lat1, const double lon2, const double lat2)
{
const auto p1(UtmCoordinate::fromGeographic(lon1, lat1));
const auto p2(UtmCoordinate::fromGeographic(lon2, lat2, p1.zone));
return squareDistance(p1, p2);
}
}
inline double squareDistance(const UtmCoordinate& p1, const double lon2, const double lat2)
{
inline double squareDistance(const UtmCoordinate &p1, const double lon2, const double lat2)
{
const auto p2(UtmCoordinate::fromGeographic(lon2, lat2, p1.zone));
return squareDistance(p1, p2);
}
}
inline double distance(const UtmCoordinate& p1, const UtmCoordinate& p2)
{
inline double distance(const UtmCoordinate &p1, const UtmCoordinate &p2)
{
if (p1.zone != p2.zone)
{
Q_ASSERT(false);
return std::nan("");
Q_ASSERT(false);
return std::nan("");
}
return sqrt(squareDistance(p1, p2));
}
}
LTSCOORDTRANS_EXPORT double distance(const QPointF& p1, const QPointF& p2);
LTSCOORDTRANS_EXPORT double distance(const QPointF &p1, const QPointF &p2);
inline double distance(const double lon1, const double lat1, const double lon2, const double lat2)
{
inline double distance(const double lon1, const double lat1, const double lon2, const double lat2)
{
return sqrt(squareDistance(lon1, lat1, lon2, lat2));
}
}
inline double distance(const UtmCoordinate& p1, const double lon2, const double lat2)
{
inline double distance(const UtmCoordinate &p1, const double lon2, const double lat2)
{
return sqrt(squareDistance(p1, lon2, lat2));
}
}
LTSCOORDTRANS_EXPORT void dumpConversionCounter();
LTSCOORDTRANS_EXPORT void dumpConversionCounter();
LTSCOORDTRANS_EXPORT long getConversionCounter_MGRS_Forward();
LTSCOORDTRANS_EXPORT long getConversionCounter_MGRS_Reverse();
LTSCOORDTRANS_EXPORT long getConversionCounter_WGS84_Forward();
LTSCOORDTRANS_EXPORT long getConversionCounter_WGS84_Reverse();
LTSCOORDTRANS_EXPORT long getConversionCounter_UTMUPS_Forward();
LTSCOORDTRANS_EXPORT long getConversionCounter_UTMUPS_Reverse();
LTSCOORDTRANS_EXPORT long getConversionCounter_MGRS_Forward();
LTSCOORDTRANS_EXPORT long getConversionCounter_MGRS_Reverse();
LTSCOORDTRANS_EXPORT long getConversionCounter_WGS84_Forward();
LTSCOORDTRANS_EXPORT long getConversionCounter_WGS84_Reverse();
LTSCOORDTRANS_EXPORT long getConversionCounter_UTMUPS_Forward();
LTSCOORDTRANS_EXPORT long getConversionCounter_UTMUPS_Reverse();
LTSCOORDTRANS_EXPORT std::ostream& operator<<(std::ostream& stream, const UtmCoordinate& coord);
LTSCOORDTRANS_EXPORT std::ostream &operator<<(std::ostream &stream, const UtmCoordinate &coord);
class LTSCOORDTRANS_EXPORT UtmCoordinate3D : public LtsCoordTrans::UtmCoordinate
{
class LTSCOORDTRANS_EXPORT UtmCoordinate3D : public LtsCoordTrans::UtmCoordinate
{
using BaseClass = LtsCoordTrans::UtmCoordinate;
public:
UtmCoordinate3D()
{
reset();
}
UtmCoordinate3D() { reset(); }
explicit UtmCoordinate3D(const LtsCoordTrans::UtmCoordinate& utm2d, double _zValue = std::nan("")) : BaseClass()
explicit UtmCoordinate3D(const LtsCoordTrans::UtmCoordinate &utm2d, double _zValue = std::nan(""))
: BaseClass()
{
zone = utm2d.zone;
northp = utm2d.northp;
x = utm2d.x;
y = utm2d.y;
zValue = _zValue;
zone = utm2d.zone;
northp = utm2d.northp;
x = utm2d.x;
y = utm2d.y;
zValue = _zValue;
}
void reset()
{
zone = -1;
northp = true;
zone = -1;
northp = true;
x = 0.;
y = 0.;
zValue = std::nan("");
x = 0.;
y = 0.;
zValue = std::nan("");
}
double z() const
{
return zValue;
}
double z() const { return zValue; }
protected:
double zValue{std::nan("")};
};
};
} // namespace LtsCoordTrans
@@ -13,7 +13,7 @@ QTEST_MAIN(coordtrans_test)
void coordtrans_test::initTestCase()
{
qDebug("sizeof(UtmCoordinate) = %lu", sizeof(LtsCoordTrans::UtmCoordinate));
qDebug("sizeof(UtmCoordinate) = %lu", sizeof(LtsCoordTrans::UtmCoordinate));
}
void coordtrans_test::cleanupTestCase() {}
@@ -21,380 +21,394 @@ void coordtrans_test::cleanupTestCase() {}
void coordtrans_test::testFromGeographic()
{
LtsCoordTrans::UtmCoordinate utm;
QPointF lonlat;
LtsCoordTrans::UtmCoordinate utm;
QPointF lonlat;
lonlat = QPointF(8.6264954126, 53.1138437183) * LtsCoordTrans::deg2rad();
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y(), -1);
QCOMPARE(utm.mgrs(0), QStringLiteral("32U MD"));
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QCOMPARE(utm.mgrs(8), QStringLiteral("32U MD 74999999 84999999"));
lonlat = QPointF(8.6264954126, 53.1138437183) * LtsCoordTrans::deg2rad();
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y(), -1);
QCOMPARE(utm.mgrs(0), QStringLiteral("32U MD"));
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QCOMPARE(utm.mgrs(8), QStringLiteral("32U MD 74999999 84999999"));
lonlat = QPointF(11.3003696521, 52.8224535191) * LtsCoordTrans::deg2rad();
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y(), -1);
QCOMPARE(utm.mgrs(0), QStringLiteral("32U PD"));
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QCOMPARE(utm.mgrs(5), QStringLiteral("32U PD 55000 55000"));
lonlat = QPointF(11.3003696521, 52.8224535191) * LtsCoordTrans::deg2rad();
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y(), -1);
QCOMPARE(utm.mgrs(0), QStringLiteral("32U PD"));
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QCOMPARE(utm.mgrs(5), QStringLiteral("32U PD 55000 55000"));
lonlat = QPointF(54.8821607021, 24.2631973752) * LtsCoordTrans::deg2rad();
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y(), -1);
QCOMPARE(utm.mgrs(0), QStringLiteral("40R BM"));
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QCOMPARE(utm.mgrs(5), QStringLiteral("40R BM 85000 85000"));
lonlat = QPointF(54.8821607021, 24.2631973752) * LtsCoordTrans::deg2rad();
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y(), -1);
QCOMPARE(utm.mgrs(0), QStringLiteral("40R BM"));
utm = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QCOMPARE(utm.mgrs(5), QStringLiteral("40R BM 85000 85000"));
utm = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("40R BM 00000 00000"));
QCOMPARE(utm.mgrs(0), QStringLiteral("40Q BM"));
utm = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("40R BM 00000 00000"));
QCOMPARE(utm.mgrs(0), QStringLiteral("40Q BM"));
}
void coordtrans_test::testMgrsFromGeographic()
{
QString mgrs;
QPointF lonlat;
QString mgrs;
QPointF lonlat;
lonlat = QPointF(8.6191049344, 53.1048309844) * LtsCoordTrans::deg2rad();
mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 9);
QCOMPARE(mgrs, QStringLiteral("32U MD 745000000 840000000"));
lonlat = QPointF(8.6191049344, 53.1048309844) * LtsCoordTrans::deg2rad();
mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 9);
QCOMPARE(mgrs, QStringLiteral("32U MD 745000000 840000000"));
mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 8, false);
QCOMPARE(mgrs, QStringLiteral("32UMD7450000084000000"));
mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 8, false);
QCOMPARE(mgrs, QStringLiteral("32UMD7450000084000000"));
}
void coordtrans_test::testRelativeMetricalOffet_data()
{
QTest::addColumn<QPoint>("offset");
QTest::addColumn<QString>("correctMgrs");
QTest::addColumn<QPoint>("offset");
QTest::addColumn<QString>("correctMgrs");
QTest::newRow("set 1") << QPoint(5, 5) << QStringLiteral("32U PD 99995 99995");
QTest::newRow("set 1") << QPoint(5, 5) << QStringLiteral("32U PD 99995 99995");
QTest::newRow("set 2") << QPoint(100, 100) << QStringLiteral("32U QE 00090 00090");
QTest::newRow("set 3") << QPoint(500, 500) << QStringLiteral("32U QE 00490 00490");
QTest::newRow("set 2") << QPoint(100, 100) << QStringLiteral("32U QE 00090 00090");
QTest::newRow("set 3") << QPoint(500, 500) << QStringLiteral("32U QE 00490 00490");
}
void coordtrans_test::testRelativeMetricalOffet()
{
QFETCH(QPoint, offset);
QFETCH(QString, correctMgrs);
QFETCH(QPoint, offset);
QFETCH(QString, correctMgrs);
const LtsCoordTrans::UtmCoordinate& utmRef =
LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 99990 99990"));
qDebug() << "utmRef = " << utmRef.mgrs();
const LtsCoordTrans::UtmCoordinate &utmRef = LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32U PD 99990 99990"));
qDebug() << "utmRef = " << utmRef.mgrs();
{
LtsCoordTrans::UtmCoordinate utmRaw;
utmRaw.x = utmRef.x + offset.x();
utmRaw.y = utmRef.y + offset.y();
utmRaw.zone = utmRef.zone;
qDebug() << "offset = " << offset << " - utmRaw = " << utmRaw.mgrs();
{
LtsCoordTrans::UtmCoordinate utmRaw;
utmRaw.x = utmRef.x + offset.x();
utmRaw.y = utmRef.y + offset.y();
utmRaw.zone = utmRef.zone;
qDebug() << "offset = " << offset << " - utmRaw = " << utmRaw.mgrs();
QCOMPARE(utmRaw.mgrs(), correctMgrs);
}
QCOMPARE(utmRaw.mgrs(), correctMgrs);
}
{
const LtsCoordTrans::UtmCoordinate utmSimple(utmRef.zone, utmRef.x + offset.x(), utmRef.y + offset.y());
{
const LtsCoordTrans::UtmCoordinate utmSimple(utmRef.zone, utmRef.x + offset.x(), utmRef.y + offset.y());
qDebug() << "offset = " << offset << " - utmSimple = " << utmSimple.mgrs();
QCOMPARE(utmSimple.mgrs(), correctMgrs);
}
qDebug() << "offset = " << offset << " - utmSimple = " << utmSimple.mgrs();
QCOMPARE(utmSimple.mgrs(), correctMgrs);
}
}
QRectF createArea(const QString& base, int xCenter, int yCenter, int width, int height)
QRectF createArea(const QString &base, int xCenter, int yCenter, int width, int height)
{
QRectF areaRect = QRectF(xCenter - width / 2, yCenter - height / 2, width, height);
LtsCoordTrans::UtmCoordinate utmBase(
LtsCoordTrans::UtmCoordinate::fromGeographic(LtsCoordTrans::geographicFromMgrs(base)));
const QPointF topLeft(utmBase.geographic(areaRect.left(), areaRect.top()));
const QPointF bottomRight(utmBase.geographic(areaRect.right(), areaRect.bottom()));
QRectF areaRect = QRectF(xCenter - width / 2, yCenter - height / 2, width, height);
LtsCoordTrans::UtmCoordinate utmBase(LtsCoordTrans::UtmCoordinate::fromGeographic(LtsCoordTrans::geographicFromMgrs(base)));
const QPointF topLeft(utmBase.geographic(areaRect.left(), areaRect.top()));
const QPointF bottomRight(utmBase.geographic(areaRect.right(), areaRect.bottom()));
QRectF rect(topLeft, bottomRight);
return rect;
QRectF rect(topLeft, bottomRight);
return rect;
}
void coordtrans_test::testAddMarginToArea()
{
{
qDebug() << "Altmark";
QRectF area = createArea(QStringLiteral("32U PD 0000000000"), 50000, 10000, 30000, 30000);
QRectF area1Increased = LtsCoordTrans::addMarginToArea(area, QSize(5000, 20000));
{
qDebug() << "Altmark";
QRectF area = createArea(QStringLiteral("32U PD 0000000000"), 50000, 10000, 30000, 30000);
QRectF area1Increased = LtsCoordTrans::addMarginToArea(area, QSize(5000, 20000));
qDebug() << "topLeft : " << qSetRealNumberPrecision(15) << area.topLeft()
<< " - degree:" << area.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "topLeftInc : " << qSetRealNumberPrecision(15) << area1Increased.topLeft()
<< " - degree:" << area1Increased.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "topLeft : " << qSetRealNumberPrecision(15) << area.topLeft() << " - degree:" << area.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "topLeftInc : " << qSetRealNumberPrecision(15) << area1Increased.topLeft() << " - degree:" << area1Increased.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRight : " << qSetRealNumberPrecision(15) << area.bottomRight()
<< " - degree:" << area.bottomRight() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRightInc : " << qSetRealNumberPrecision(15) << area1Increased.bottomRight()
<< " - degree:" << area1Increased.bottomRight() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRight : " << qSetRealNumberPrecision(15) << area.bottomRight() << " - degree:" << area.bottomRight() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRightInc : " << qSetRealNumberPrecision(15) << area1Increased.bottomRight()
<< " - degree:" << area1Increased.bottomRight() * LtsCoordTrans::rad2deg();
QVERIFY2(area1Increased.topLeft().x() < area.topLeft().x(), "addMarginToArea topLeft X failed");
QVERIFY2(area1Increased.topLeft().y() < area.topLeft().y(), "addMarginToArea topLeft Y failed");
QVERIFY2(area1Increased.topLeft().x() < area.topLeft().x(), "addMarginToArea topLeft X failed");
QVERIFY2(area1Increased.topLeft().y() < area.topLeft().y(), "addMarginToArea topLeft Y failed");
QVERIFY2(area1Increased.bottomRight().x() > area.bottomRight().x(), "addMarginToArea bottomRight X failed");
QVERIFY2(area1Increased.bottomRight().y() > area.bottomRight().y(), "addMarginToArea bottomRight Y failed");
}
QVERIFY2(area1Increased.bottomRight().x() > area.bottomRight().x(), "addMarginToArea bottomRight X failed");
QVERIFY2(area1Increased.bottomRight().y() > area.bottomRight().y(), "addMarginToArea bottomRight Y failed");
}
{
qDebug() << "Luxemburg";
QRectF area = createArea(QStringLiteral("32U LA 0000000000"), 100, 100, 5000, 5000);
QRectF area1Increased = LtsCoordTrans::addMarginToArea(area, QSize(50000, 20000));
{
qDebug() << "Luxemburg";
QRectF area = createArea(QStringLiteral("32U LA 0000000000"), 100, 100, 5000, 5000);
QRectF area1Increased = LtsCoordTrans::addMarginToArea(area, QSize(50000, 20000));
qDebug() << "topLeft : " << qSetRealNumberPrecision(15) << area.topLeft()
<< " - degree:" << area.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "topLeftInc : " << qSetRealNumberPrecision(15) << area1Increased.topLeft()
<< " - degree:" << area1Increased.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "topLeft : " << qSetRealNumberPrecision(15) << area.topLeft() << " - degree:" << area.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "topLeftInc : " << qSetRealNumberPrecision(15) << area1Increased.topLeft() << " - degree:" << area1Increased.topLeft() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRight : " << qSetRealNumberPrecision(15) << area.bottomRight()
<< " - degree:" << area.bottomRight() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRightInc : " << qSetRealNumberPrecision(15) << area1Increased.bottomRight()
<< " - degree:" << area1Increased.bottomRight() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRight : " << qSetRealNumberPrecision(15) << area.bottomRight() << " - degree:" << area.bottomRight() * LtsCoordTrans::rad2deg();
qDebug() << "bottomRightInc : " << qSetRealNumberPrecision(15) << area1Increased.bottomRight()
<< " - degree:" << area1Increased.bottomRight() * LtsCoordTrans::rad2deg();
QVERIFY2(area1Increased.topLeft().x() < area.topLeft().x(), "addMarginToArea topLeft X failed");
QVERIFY2(area1Increased.topLeft().y() < area.topLeft().y(), "addMarginToArea topLeft Y failed");
QVERIFY2(area1Increased.topLeft().x() < area.topLeft().x(), "addMarginToArea topLeft X failed");
QVERIFY2(area1Increased.topLeft().y() < area.topLeft().y(), "addMarginToArea topLeft Y failed");
QVERIFY2(area1Increased.bottomRight().x() > area.bottomRight().x(), "addMarginToArea bottomRight X failed");
QVERIFY2(area1Increased.bottomRight().y() > area.bottomRight().y(), "addMarginToArea bottomRight Y failed");
}
QVERIFY2(area1Increased.bottomRight().x() > area.bottomRight().x(), "addMarginToArea bottomRight X failed");
QVERIFY2(area1Increased.bottomRight().y() > area.bottomRight().y(), "addMarginToArea bottomRight Y failed");
}
}
void coordtrans_test::testIncreaseRect()
{
QPointF lonlat = QPointF(8.6191049344, 53.1048309844) * LtsCoordTrans::deg2rad();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 9);
QCOMPARE(mgrs, QStringLiteral("32U MD 745000000 840000000"));
QPointF lonlat = QPointF(8.6191049344, 53.1048309844) * LtsCoordTrans::deg2rad();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 9);
QCOMPARE(mgrs, QStringLiteral("32U MD 745000000 840000000"));
const LtsCoordTrans::UtmCoordinate centerPoint =
LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
const LtsCoordTrans::UtmCoordinate centerPoint = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
LtsCoordTrans::UtmCoordinate topLeftUtm;
LtsCoordTrans::UtmCoordinate topLeftUtm2;
LtsCoordTrans::UtmCoordinate topLeftUtm;
LtsCoordTrans::UtmCoordinate topLeftUtm2;
{
QPointF topLeftGeo = centerPoint.geographic(-1111, 2222);
QPointF bottomRightGeo = centerPoint.geographic(3000, -4000);
{
QPointF topLeftGeo = centerPoint.geographic(-1111, 2222);
QPointF bottomRightGeo = centerPoint.geographic(3000, -4000);
topLeftUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(topLeftGeo);
const LtsCoordTrans::UtmCoordinate bottomRightUtm =
LtsCoordTrans::UtmCoordinate::fromGeographic(bottomRightGeo);
qDebug() << "topLeftUtm: " << topLeftUtm.x << " - " << qSetRealNumberPrecision(15) << topLeftUtm.y;
qDebug() << "bottomRightUtm: " << bottomRightUtm.x << " - " << qSetRealNumberPrecision(15)
<< bottomRightUtm.y;
}
topLeftUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(topLeftGeo);
const LtsCoordTrans::UtmCoordinate bottomRightUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(bottomRightGeo);
qDebug() << "topLeftUtm: " << topLeftUtm.x << " - " << qSetRealNumberPrecision(15) << topLeftUtm.y;
qDebug() << "bottomRightUtm: " << bottomRightUtm.x << " - " << qSetRealNumberPrecision(15) << bottomRightUtm.y;
}
{
topLeftUtm2.x = centerPoint.x - 1111;
topLeftUtm2.y = centerPoint.y + 2222;
{
topLeftUtm2.x = centerPoint.x - 1111;
topLeftUtm2.y = centerPoint.y + 2222;
LtsCoordTrans::UtmCoordinate bottomRightUtm2;
bottomRightUtm2.x = centerPoint.x + 3000;
bottomRightUtm2.y = centerPoint.y - 4000;
LtsCoordTrans::UtmCoordinate bottomRightUtm2;
bottomRightUtm2.x = centerPoint.x + 3000;
bottomRightUtm2.y = centerPoint.y - 4000;
qDebug() << "topLeftUtm2: " << topLeftUtm2.x << " - " << qSetRealNumberPrecision(15) << topLeftUtm2.y;
qDebug() << "bottomRightUtm2: " << bottomRightUtm2.x << " - " << qSetRealNumberPrecision(15)
<< bottomRightUtm2.y;
}
qDebug() << "topLeftUtm2: " << topLeftUtm2.x << " - " << qSetRealNumberPrecision(15) << topLeftUtm2.y;
qDebug() << "bottomRightUtm2: " << bottomRightUtm2.x << " - " << qSetRealNumberPrecision(15) << bottomRightUtm2.y;
}
QVERIFY2(qFuzzyCompare(topLeftUtm.x, topLeftUtm2.x), "testIncreaseRect x failed");
QVERIFY2(qFuzzyCompare(topLeftUtm.y, topLeftUtm2.y), "testIncreaseRect y failed");
QVERIFY2(qFuzzyCompare(topLeftUtm.x, topLeftUtm2.x), "testIncreaseRect x failed");
QVERIFY2(qFuzzyCompare(topLeftUtm.y, topLeftUtm2.y), "testIncreaseRect y failed");
}
void coordtrans_test::testIncreaseRect2()
{
QPointF lonlat = QPointF(8.6191049344, 53.1048309844) * LtsCoordTrans::deg2rad();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 9);
QCOMPARE(mgrs, QStringLiteral("32U MD 745000000 840000000"));
QPointF lonlat = QPointF(8.6191049344, 53.1048309844) * LtsCoordTrans::deg2rad();
QString mgrs = LtsCoordTrans::mgrsFromGeographic(lonlat.x(), lonlat.y(), 9);
QCOMPARE(mgrs, QStringLiteral("32U MD 745000000 840000000"));
QRectF myRect;
QRectF myRectIncreased;
QRectF myRect;
QRectF myRectIncreased;
{
const LtsCoordTrans::UtmCoordinate centerPoint =
LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
{
const LtsCoordTrans::UtmCoordinate centerPoint = LtsCoordTrans::UtmCoordinate::fromGeographic(lonlat.x(), lonlat.y());
QPointF topLeftGeo = centerPoint.geographic(-3000, 2000);
QPointF bottomRightGeo = centerPoint.geographic(3000, -2000);
myRect = QRectF(topLeftGeo, bottomRightGeo).normalized();
QPointF topLeftGeo = centerPoint.geographic(-3000, 2000);
QPointF bottomRightGeo = centerPoint.geographic(3000, -2000);
myRect = QRectF(topLeftGeo, bottomRightGeo).normalized();
qDebug() << "myRect : " << myRect;
qDebug() << "myRect center : " << myRect.center();
qDebug() << "myRect height : " << myRect.height();
}
qDebug() << "myRect : " << myRect;
qDebug() << "myRect center : " << myRect.center();
qDebug() << "myRect height : " << myRect.height();
}
{
const QPointF centerGeo = myRect.center();
const LtsCoordTrans::UtmCoordinate centerUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(centerGeo);
{
const QPointF centerGeo = myRect.center();
const LtsCoordTrans::UtmCoordinate centerUtm = LtsCoordTrans::UtmCoordinate::fromGeographic(centerGeo);
QPointF topLeftGeo = centerUtm.geographic(-6000, 4000);
QPointF bottomRightGeo = centerUtm.geographic(6000, -4000);
QPointF topLeftGeo = centerUtm.geographic(-6000, 4000);
QPointF bottomRightGeo = centerUtm.geographic(6000, -4000);
myRectIncreased = QRectF(topLeftGeo, bottomRightGeo).normalized();
myRectIncreased = QRectF(topLeftGeo, bottomRightGeo).normalized();
qDebug() << "myRectIncreased : " << myRectIncreased;
qDebug() << "myRectIncreased center: " << myRectIncreased.center();
qDebug() << "myRectIncreased height: " << myRectIncreased.height();
}
qDebug() << "myRectIncreased : " << myRectIncreased;
qDebug() << "myRectIncreased center: " << myRectIncreased.center();
qDebug() << "myRectIncreased height: " << myRectIncreased.height();
}
QVERIFY2((int)(myRectIncreased.center().x() * 10000) == (int)(myRect.center().x() * 10000),
"testIncreaseRect2 centerX failed");
QVERIFY2((int)(myRectIncreased.center().y() * 10000) == (int)(myRect.center().y() * 10000),
"testIncreaseRect2 centerY failed");
QVERIFY2((int)(myRectIncreased.center().x() * 10000) == (int)(myRect.center().x() * 10000), "testIncreaseRect2 centerX failed");
QVERIFY2((int)(myRectIncreased.center().y() * 10000) == (int)(myRect.center().y() * 10000), "testIncreaseRect2 centerY failed");
QVERIFY2(myRectIncreased.width() > myRect.width(), "testIncreaseRect2 width failed");
QVERIFY2(myRectIncreased.height() > myRect.height(), "testIncreaseRect2 height failed");
QVERIFY2(myRectIncreased.width() > myRect.width(), "testIncreaseRect2 width failed");
QVERIFY2(myRectIncreased.height() > myRect.height(), "testIncreaseRect2 height failed");
}
void coordtrans_test::testGeographicFromMgrs()
{
QString mgrs(QStringLiteral("32UPD7654398765"));
QString mgrs(QStringLiteral("32UPD7654398765"));
QPointF geographic = LtsCoordTrans::geographicFromMgrs(mgrs);
QCOMPARE(geographic, QPointF(11.6436815550, 53.2088411454) * LtsCoordTrans::deg2rad());
QPointF geographic = LtsCoordTrans::geographicFromMgrs(mgrs);
QCOMPARE(geographic, QPointF(11.6436815550, 53.2088411454) * LtsCoordTrans::deg2rad());
}
void coordtrans_test::testMgrsSquares()
{
checkArea(QStringLiteral("32U PD 0000000000"), 50000, 10000, 30000, 30000,
{QStringLiteral("32U PC"), QStringLiteral("32U PD")});
checkArea(QStringLiteral("32U MD 0000000000"), 50000, 10000, 30000, 30000,
{QStringLiteral("32U MC"), QStringLiteral("32U MD")});
checkArea(QStringLiteral("32U MD 0000000000"), 89999, 89999, 21000, 21000,
{QStringLiteral("32U MD"), QStringLiteral("32U ME"), QStringLiteral("32U ND"), QStringLiteral("32U NE")});
checkArea(QStringLiteral("32U PD 0000000000"), 50000, 10000, 30000, 30000, {QStringLiteral("32U PC"), QStringLiteral("32U PD")});
checkArea(QStringLiteral("32U MD 0000000000"), 50000, 10000, 30000, 30000, {QStringLiteral("32U MC"), QStringLiteral("32U MD")});
checkArea(QStringLiteral("32U MD 0000000000"),
89999,
89999,
21000,
21000,
{QStringLiteral("32U MD"), QStringLiteral("32U ME"), QStringLiteral("32U ND"), QStringLiteral("32U NE")});
checkArea(QStringLiteral("39Q XG 0000000000"), 40000, 35000, 60000, 70000,
{QStringLiteral("39Q XG"), QStringLiteral("39R XG")});
checkArea(QStringLiteral("40R CP 0000000000"), 94000, 9000, 7000, 16000, {QStringLiteral("40R CP")});
checkArea(QStringLiteral("40R DN 0000000000"), 500, 95500, 12000, 7000,
{QStringLiteral("40R CN"), QStringLiteral("40R DN")});
checkArea(QStringLiteral("40R DN 0000000000"), 500, 96760, 30000, 30000,
{QStringLiteral("40R CN"), QStringLiteral("40R CP"), QStringLiteral("40R DN"), QStringLiteral("40R DP")});
checkArea(QStringLiteral("40R BM 0000000000"), 59000, 59500, 46000, 40000,
{QStringLiteral("40Q BM"), QStringLiteral("40R BM")});
checkArea(QStringLiteral("39Q XG 0000000000"), 40000, 35000, 60000, 70000, {QStringLiteral("39Q XG"), QStringLiteral("39R XG")});
checkArea(QStringLiteral("40R CP 0000000000"), 94000, 9000, 7000, 16000, {QStringLiteral("40R CP")});
checkArea(QStringLiteral("40R DN 0000000000"), 500, 95500, 12000, 7000, {QStringLiteral("40R CN"), QStringLiteral("40R DN")});
checkArea(QStringLiteral("40R DN 0000000000"),
500,
96760,
30000,
30000,
{QStringLiteral("40R CN"), QStringLiteral("40R CP"), QStringLiteral("40R DN"), QStringLiteral("40R DP")});
checkArea(QStringLiteral("40R BM 0000000000"), 59000, 59500, 46000, 40000, {QStringLiteral("40Q BM"), QStringLiteral("40R BM")});
checkArea(QStringLiteral("32U LA 0000000000"), 10000, 10000, 5000, 5000,
{
QStringLiteral("32U LA"),
});
checkArea(QStringLiteral("32U LA 0000000000"),
10000,
10000,
5000,
5000,
{
QStringLiteral("32U LA"),
});
checkArea(QStringLiteral("32U LA 0000000000"), 100, 100, 60000, 60000,
{QStringLiteral("31U GQ"), QStringLiteral("31U GR"), QStringLiteral("32U KA"), QStringLiteral("32U KV"),
QStringLiteral("32U LA"), QStringLiteral("32U LV")});
checkArea(QStringLiteral("32U LA 0000000000"),
100,
100,
60000,
60000,
{QStringLiteral("31U GQ"), QStringLiteral("31U GR"), QStringLiteral("32U KA"), QStringLiteral("32U KV"), QStringLiteral("32U LA"), QStringLiteral("32U LV")});
checkArea(QStringLiteral("32U LA 0000000000"), 100, 100, 150000, 150000,
{QStringLiteral("31U FQ"), QStringLiteral("31U FR"), QStringLiteral("31U GQ"), QStringLiteral("31U GR"),
QStringLiteral("32U KA"), QStringLiteral("32U KV"), QStringLiteral("32U LA"), QStringLiteral("32U LV")});
checkArea(QStringLiteral("32U LA 0000000000"),
100,
100,
150000,
150000,
{QStringLiteral("31U FQ"),
QStringLiteral("31U FR"),
QStringLiteral("31U GQ"),
QStringLiteral("31U GR"),
QStringLiteral("32U KA"),
QStringLiteral("32U KV"),
QStringLiteral("32U LA"),
QStringLiteral("32U LV")});
checkArea(QStringLiteral("32U LA 0000000000"), 100, 100, 200000, 200000,
{QStringLiteral("31U FP"), QStringLiteral("31U FQ"), QStringLiteral("31U FR"), QStringLiteral("31U GP"),
QStringLiteral("31U GQ"), QStringLiteral("31U GR"), QStringLiteral("31U GS"), QStringLiteral("32U KA"),
QStringLiteral("32U KB"), QStringLiteral("32U KV"), QStringLiteral("32U LA"), QStringLiteral("32U LB"),
QStringLiteral("32U LV"), QStringLiteral("32U MA"), QStringLiteral("32U MB"), QStringLiteral("32U MV")});
checkArea(QStringLiteral("32U LA 0000000000"),
100,
100,
200000,
200000,
{QStringLiteral("31U FP"),
QStringLiteral("31U FQ"),
QStringLiteral("31U FR"),
QStringLiteral("31U GP"),
QStringLiteral("31U GQ"),
QStringLiteral("31U GR"),
QStringLiteral("31U GS"),
QStringLiteral("32U KA"),
QStringLiteral("32U KB"),
QStringLiteral("32U KV"),
QStringLiteral("32U LA"),
QStringLiteral("32U LB"),
QStringLiteral("32U LV"),
QStringLiteral("32U MA"),
QStringLiteral("32U MB"),
QStringLiteral("32U MV")});
}
QVector<LtsCoordTrans::UtmCoordinate> checkAreaGetMgrsSquares(const QString& base, int xCenter, int yCenter, int width,
int height)
QVector<LtsCoordTrans::UtmCoordinate> checkAreaGetMgrsSquares(const QString &base, int xCenter, int yCenter, int width, int height)
{
QRectF areaRect = QRectF(xCenter - width / 2, yCenter - height / 2, width, height);
LtsCoordTrans::UtmCoordinate utmBase(
LtsCoordTrans::UtmCoordinate::fromGeographic(LtsCoordTrans::geographicFromMgrs(base)));
const QPointF topLeft(utmBase.geographic(areaRect.left(), areaRect.top()));
const QPointF bottomRight(utmBase.geographic(areaRect.right(), areaRect.bottom()));
QRectF areaRect = QRectF(xCenter - width / 2, yCenter - height / 2, width, height);
LtsCoordTrans::UtmCoordinate utmBase(LtsCoordTrans::UtmCoordinate::fromGeographic(LtsCoordTrans::geographicFromMgrs(base)));
const QPointF topLeft(utmBase.geographic(areaRect.left(), areaRect.top()));
const QPointF bottomRight(utmBase.geographic(areaRect.right(), areaRect.bottom()));
const auto squares = LtsCoordTrans::getMgrsSquares(QRectF(topLeft, bottomRight), false, false);
const auto squares = LtsCoordTrans::getMgrsSquares(QRectF(topLeft, bottomRight), false, false);
QStringList src;
src.reserve(squares.size());
for (const auto& utm : squares)
src += utm.mgrs(0);
src.sort();
QStringList src;
src.reserve(squares.size());
for (const auto &utm : squares)
src += utm.mgrs(0);
src.sort();
return squares;
return squares;
}
void coordtrans_test::testMgrsSquaresWithSurrounding()
{
int initialSize = 5000;
int initialSize = 5000;
QVector<LtsCoordTrans::UtmCoordinate> squares1 =
checkAreaGetMgrsSquares(QStringLiteral("32U NC 0000000000"), 50000, 50000, initialSize, initialSize);
QVector<LtsCoordTrans::UtmCoordinate> squares1 = checkAreaGetMgrsSquares(QStringLiteral("32U NC 0000000000"), 50000, 50000, initialSize, initialSize);
QVERIFY2(squares1.size() == 1, "checkAreaGetMgrsSquares failed");
QVERIFY2(squares1.size() == 1, "checkAreaGetMgrsSquares failed");
int biggerSize = initialSize + (1 * 110000);
QVector<LtsCoordTrans::UtmCoordinate> squares9 =
checkAreaGetMgrsSquares(QStringLiteral("32U NC 0000000000"), 50000, 50000, biggerSize, biggerSize);
int biggerSize = initialSize + (1 * 110000);
QVector<LtsCoordTrans::UtmCoordinate> squares9 = checkAreaGetMgrsSquares(QStringLiteral("32U NC 0000000000"), 50000, 50000, biggerSize, biggerSize);
QVERIFY2(squares9.size() == 9, "checkAreaGetMgrsSquares biggerSize failed");
QVERIFY2(squares9.size() == 9, "checkAreaGetMgrsSquares biggerSize failed");
int muchBiggerSize = initialSize + (3 * 110000);
QVector<LtsCoordTrans::UtmCoordinate> square33 =
checkAreaGetMgrsSquares(QStringLiteral("32U NC 0000000000"), 50000, 50000, muchBiggerSize, muchBiggerSize);
int muchBiggerSize = initialSize + (3 * 110000);
QVector<LtsCoordTrans::UtmCoordinate> square33 = checkAreaGetMgrsSquares(QStringLiteral("32U NC 0000000000"), 50000, 50000, muchBiggerSize, muchBiggerSize);
QVERIFY2(square33.size() == 33, "checkAreaGetMgrsSquares muchBiggerSize failed");
QVERIFY2(square33.size() == 33, "checkAreaGetMgrsSquares muchBiggerSize failed");
QStringList string1;
string1.reserve(squares1.size());
for (const LtsCoordTrans::UtmCoordinate& item : std::as_const(squares1))
string1.append(item.mgrs(0));
QStringList string1;
string1.reserve(squares1.size());
for (const LtsCoordTrans::UtmCoordinate &item : std::as_const(squares1))
string1.append(item.mgrs(0));
QStringList string9;
string9.reserve(squares9.size());
for (const LtsCoordTrans::UtmCoordinate& item : std::as_const(squares9))
string9.append(item.mgrs(0));
QStringList string9;
string9.reserve(squares9.size());
for (const LtsCoordTrans::UtmCoordinate &item : std::as_const(squares9))
string9.append(item.mgrs(0));
QStringList string33;
string33.reserve(square33.size());
for (const LtsCoordTrans::UtmCoordinate& item : std::as_const(square33))
string33.append(item.mgrs(0));
QStringList string33;
string33.reserve(square33.size());
for (const LtsCoordTrans::UtmCoordinate &item : std::as_const(square33))
string33.append(item.mgrs(0));
{
QStringList surroundingStrings;
surroundingStrings.reserve(squares9.size());
for (const QString& str : std::as_const(string9))
if (!string1.contains(str))
surroundingStrings.append(str);
{
QStringList surroundingStrings;
surroundingStrings.reserve(squares9.size());
for (const QString &str : std::as_const(string9))
if (!string1.contains(str))
surroundingStrings.append(str);
QVERIFY2(surroundingStrings.size() == 8, "checkAreaGetMgrsSquares squaresDiff failed");
}
QVERIFY2(surroundingStrings.size() == 8, "checkAreaGetMgrsSquares squaresDiff failed");
}
{
QStringList surroundingStrings;
surroundingStrings.reserve(string33.size());
for (const QString& str : std::as_const(string33))
if (!string1.contains(str))
surroundingStrings.append(str);
{
QStringList surroundingStrings;
surroundingStrings.reserve(string33.size());
for (const QString &str : std::as_const(string33))
if (!string1.contains(str))
surroundingStrings.append(str);
QVERIFY2(surroundingStrings.size() == 32, "checkAreaGetMgrsSquares squaresDiff failed");
}
QVERIFY2(surroundingStrings.size() == 32, "checkAreaGetMgrsSquares squaresDiff failed");
}
}
void coordtrans_test::checkArea(const QString& base, int xCenter, int yCenter, int width, int height,
const QStringList& coords)
void coordtrans_test::checkArea(const QString &base, int xCenter, int yCenter, int width, int height, const QStringList &coords)
{
qDebug() << "checkArea : base: " << base;
QRectF areaRect = QRectF(xCenter - width / 2, yCenter - height / 2, width, height);
LtsCoordTrans::UtmCoordinate utmBase(
LtsCoordTrans::UtmCoordinate::fromGeographic(LtsCoordTrans::geographicFromMgrs(base)));
const QPointF topLeft(utmBase.geographic(areaRect.left(), areaRect.top()));
const QPointF bottomRight(utmBase.geographic(areaRect.right(), areaRect.bottom()));
qDebug() << "TopLeft: " << topLeft * LtsCoordTrans::rad2deg();
qDebug() << "BottomRight: " << bottomRight * LtsCoordTrans::rad2deg();
qDebug() << "checkArea : base: " << base;
QRectF areaRect = QRectF(xCenter - width / 2, yCenter - height / 2, width, height);
LtsCoordTrans::UtmCoordinate utmBase(LtsCoordTrans::UtmCoordinate::fromGeographic(LtsCoordTrans::geographicFromMgrs(base)));
const QPointF topLeft(utmBase.geographic(areaRect.left(), areaRect.top()));
const QPointF bottomRight(utmBase.geographic(areaRect.right(), areaRect.bottom()));
qDebug() << "TopLeft: " << topLeft * LtsCoordTrans::rad2deg();
qDebug() << "BottomRight: " << bottomRight * LtsCoordTrans::rad2deg();
const auto squares = LtsCoordTrans::getMgrsSquares(QRectF(topLeft, bottomRight), false, false);
const auto squares = LtsCoordTrans::getMgrsSquares(QRectF(topLeft, bottomRight), false, false);
QStringList src;
src.reserve(squares.size());
for (const auto& utm : squares)
src += utm.mgrs(0);
src.sort();
qDebug() << "src: '" << src << "' expected: '" << coords << "'";
QCOMPARE(src, coords);
QStringList src;
src.reserve(squares.size());
for (const auto &utm : squares)
src += utm.mgrs(0);
src.sort();
qDebug() << "src: '" << src << "' expected: '" << coords << "'";
QCOMPARE(src, coords);
}
@@ -7,25 +7,25 @@
class coordtrans_test : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void cleanupTestCase();
void testFromGeographic();
void testMgrsFromGeographic();
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void cleanupTestCase();
void testFromGeographic();
void testMgrsFromGeographic();
void testRelativeMetricalOffet_data();
void testRelativeMetricalOffet();
void testRelativeMetricalOffet_data();
void testRelativeMetricalOffet();
void testAddMarginToArea();
void testIncreaseRect();
void testIncreaseRect2();
void testAddMarginToArea();
void testIncreaseRect();
void testIncreaseRect2();
void testGeographicFromMgrs();
void testMgrsSquares();
void testGeographicFromMgrs();
void testMgrsSquares();
void testMgrsSquaresWithSurrounding();
void testMgrsSquaresWithSurrounding();
private:
void checkArea(const QString& base, int xCenter, int yCenter, int width, int height, const QStringList& coords);
private:
void checkArea(const QString &base, int xCenter, int yCenter, int width, int height, const QStringList &coords);
};
@@ -10,178 +10,177 @@
namespace LtsCoordWidget
{
LtsCoordWidget::LtsCoordWidget(DisplayType dt, QWidget* parent) : QWidget(parent), m_displayType(dt)
{
LtsCoordWidget::LtsCoordWidget(DisplayType dt, QWidget *parent)
: QWidget(parent)
, m_displayType(dt)
{
setFocusPolicy(Qt::StrongFocus);
rebuildUi();
}
}
void LtsCoordWidget::setCoordinate(const QPointF& geoCoord, bool bUseAsDefaultValue)
{
void LtsCoordWidget::setCoordinate(const QPointF &geoCoord, bool bUseAsDefaultValue)
{
if (m_coordinate != geoCoord)
emit coordinateChanged(geoCoord);
emit coordinateChanged(geoCoord);
if (bUseAsDefaultValue)
m_defaultCoordinate = geoCoord;
m_defaultCoordinate = geoCoord;
if (m_inputWidgetHandler)
m_inputWidgetHandler->setCoordinate(geoCoord);
}
m_inputWidgetHandler->setCoordinate(geoCoord);
}
void LtsCoordWidget::clear()
{
void LtsCoordWidget::clear()
{
if (m_inputWidgetHandler)
m_inputWidgetHandler->clear();
}
m_inputWidgetHandler->clear();
}
void LtsCoordWidget::setCoordinate(double lon, double lat, bool bUseAsDefaultValue)
{
void LtsCoordWidget::setCoordinate(double lon, double lat, bool bUseAsDefaultValue)
{
setCoordinate(QPointF(lon, lat), bUseAsDefaultValue);
}
}
QPointF LtsCoordWidget::coordinate() const
{
QPointF LtsCoordWidget::coordinate() const
{
if (!m_inputWidgetHandler)
return QPointF();
return QPointF();
return m_inputWidgetHandler->coordinate();
}
}
LtsCoordWidget::DisplayType LtsCoordWidget::displayType() const
{
LtsCoordWidget::DisplayType LtsCoordWidget::displayType() const
{
return m_displayType;
}
}
void LtsCoordWidget::setDisplayType(LtsCoordWidget::DisplayType dt)
{
void LtsCoordWidget::setDisplayType(LtsCoordWidget::DisplayType dt)
{
if (m_displayType == dt)
return;
return;
m_displayType = dt;
rebuildUi();
}
}
bool LtsCoordWidget::withResetButton() const
{
bool LtsCoordWidget::withResetButton() const
{
return m_bWithResetButton;
}
}
void LtsCoordWidget::setWithResetButton(bool bWith)
{
void LtsCoordWidget::setWithResetButton(bool bWith)
{
if (m_bWithResetButton == bWith)
return;
return;
m_bWithResetButton = bWith;
if (m_inputWidgetHandler)
m_inputWidgetHandler->resetButton()->setVisible(m_bWithResetButton);
}
m_inputWidgetHandler->resetButton()->setVisible(m_bWithResetButton);
}
bool LtsCoordWidget::showToolTip() const
{
bool LtsCoordWidget::showToolTip() const
{
return m_bShowToolTip;
}
}
void LtsCoordWidget::setShowToolTip(bool bShow)
{
void LtsCoordWidget::setShowToolTip(bool bShow)
{
if (m_bShowToolTip == bShow)
return;
return;
m_bShowToolTip = bShow;
updateToolTip();
}
}
bool LtsCoordWidget::mgrsSquareEditable() const
{
bool LtsCoordWidget::mgrsSquareEditable() const
{
return m_bMgrsSquareEditable;
}
}
void LtsCoordWidget::setMgrsSquareEditable(bool bEditable)
{
void LtsCoordWidget::setMgrsSquareEditable(bool bEditable)
{
if (m_bMgrsSquareEditable == bEditable)
return;
return;
m_bMgrsSquareEditable = bEditable;
if (m_inputWidgetHandler)
m_inputWidgetHandler->setSquaresEditable(bEditable);
}
m_inputWidgetHandler->setSquaresEditable(bEditable);
}
void LtsCoordWidget::setWithSurroundingMgrsSquares(bool bEnable)
{
void LtsCoordWidget::setWithSurroundingMgrsSquares(bool bEnable)
{
if (m_inputWidgetHandler)
m_inputWidgetHandler->setWithSurroundingSquare(bEnable);
}
m_inputWidgetHandler->setWithSurroundingSquare(bEnable);
}
void LtsCoordWidget::setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate>& geoCoords)
{
void LtsCoordWidget::setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate> &geoCoords)
{
if (m_inputWidgetHandler)
m_inputWidgetHandler->setMgrsSquares(geoCoords);
}
m_inputWidgetHandler->setMgrsSquares(geoCoords);
}
bool LtsCoordWidget::event(QEvent* event)
{
bool LtsCoordWidget::event(QEvent *event)
{
if (event->type() == QEvent::ToolTip)
updateToolTip();
updateToolTip();
return QWidget::event(event);
}
}
void LtsCoordWidget::rebuildUi()
{
void LtsCoordWidget::rebuildUi()
{
if (m_inputWidgetHandler)
{
m_inputWidgetHandler->cleanup();
delete m_inputWidgetHandler;
delete layout();
m_inputWidgetHandler->cleanup();
delete m_inputWidgetHandler;
delete layout();
}
switch (m_displayType)
{
case DisplayType::MGRS5:
m_inputWidgetHandler = new MgrsEdit(5, this);
break;
case DisplayType::MGRS7:
m_inputWidgetHandler = new MgrsEdit(7, this);
break;
case DisplayType::UTM:
case DisplayType::MGRS5:
m_inputWidgetHandler = new MgrsEdit(5, this);
break;
case DisplayType::MGRS7:
m_inputWidgetHandler = new MgrsEdit(7, this);
break;
case DisplayType::UTM:
qt_assert("DisplayType::UTM not yet implemented", __FILE__, __LINE__);
break;
case DisplayType::WGS84:
m_inputWidgetHandler = new Wgs84Edit(this);
break;
qt_assert("DisplayType::UTM not yet implemented", __FILE__, __LINE__);
break;
case DisplayType::WGS84:
m_inputWidgetHandler = new Wgs84Edit(this);
break;
}
if (!m_inputWidgetHandler)
return;
return;
m_inputWidgetHandler->setSquaresEditable(m_bMgrsSquareEditable);
m_inputWidgetHandler->resetButton()->setVisible(m_bWithResetButton);
connect(m_inputWidgetHandler->resetButton(), &QToolButton::clicked, this,
&LtsCoordWidget::onResetToDefaultCoordinate);
connect(m_inputWidgetHandler, &LtsCoordInputWidgetHandler::coordinateChanged, this,
&LtsCoordWidget::coordinateChanged);
connect(m_inputWidgetHandler, &LtsCoordInputWidgetHandler::invalidCoordinate, this,
&LtsCoordWidget::invalidCoordinate);
connect(m_inputWidgetHandler->resetButton(), &QToolButton::clicked, this, &LtsCoordWidget::onResetToDefaultCoordinate);
connect(m_inputWidgetHandler, &LtsCoordInputWidgetHandler::coordinateChanged, this, &LtsCoordWidget::coordinateChanged);
connect(m_inputWidgetHandler, &LtsCoordInputWidgetHandler::invalidCoordinate, this, &LtsCoordWidget::invalidCoordinate);
if (!m_defaultCoordinate.isNull())
m_inputWidgetHandler->setCoordinate(m_defaultCoordinate);
}
m_inputWidgetHandler->setCoordinate(m_defaultCoordinate);
}
void LtsCoordWidget::updateToolTip()
{
void LtsCoordWidget::updateToolTip()
{
QString tt;
if (m_bShowToolTip)
{
const QPointF p(coordinate());
if (!p.isNull())
{
const QString mgrs = LtsCoordTrans::mgrsFromGeographic(p.x(), p.y());
const QPointF p2(p * LtsCoordTrans::rad2deg());
tt = tr("MGRS: %1\nlat/lon: %2/%3").arg(mgrs).arg(p2.y(), 0, 'f', 10).arg(p2.x(), 0, 'f', 10);
}
const QPointF p(coordinate());
if (!p.isNull())
{
const QString mgrs = LtsCoordTrans::mgrsFromGeographic(p.x(), p.y());
const QPointF p2(p * LtsCoordTrans::rad2deg());
tt = tr("MGRS: %1\nlat/lon: %2/%3").arg(mgrs).arg(p2.y(), 0, 'f', 10).arg(p2.x(), 0, 'f', 10);
}
}
setToolTip(tt);
}
}
void LtsCoordWidget::onResetToDefaultCoordinate()
{
void LtsCoordWidget::onResetToDefaultCoordinate()
{
if (!m_inputWidgetHandler)
return;
return;
if (m_defaultCoordinate.isNull())
m_inputWidgetHandler->clear();
m_inputWidgetHandler->clear();
m_inputWidgetHandler->setCoordinate(m_defaultCoordinate);
}
}
} // namespace LtsCoordWidget
@@ -10,43 +10,53 @@ class QToolButton;
namespace LtsCoordWidget
{
class LtsCoordInputWidgetHandler;
class LtsCoordInputWidgetHandler;
class LTSCOORDWIDGET_EXPORT LtsCoordWidget : public QWidget
{
class LTSCOORDWIDGET_EXPORT LtsCoordWidget : public QWidget
{
Q_OBJECT
public:
enum class DisplayType { MGRS5, MGRS7, UTM, WGS84, MGRS = DisplayType::MGRS5 };
enum class DisplayType
{
MGRS5,
MGRS7,
UTM,
WGS84,
MGRS = DisplayType::MGRS5
};
Q_ENUM(DisplayType)
Q_PROPERTY(DisplayType displayType READ displayType WRITE setDisplayType)
Q_PROPERTY(bool withResetButton READ withResetButton WRITE setWithResetButton)
Q_PROPERTY(bool showToolTip READ showToolTip WRITE setShowToolTip)
Q_PROPERTY(bool mgrsSquareEditable READ mgrsSquareEditable WRITE setMgrsSquareEditable)
explicit LtsCoordWidget(QWidget* parent = nullptr) : LtsCoordWidget(LtsCoordWidget::DisplayType::MGRS, parent) {}
explicit LtsCoordWidget(QWidget *parent = nullptr)
: LtsCoordWidget(LtsCoordWidget::DisplayType::MGRS, parent)
{
}
explicit LtsCoordWidget(DisplayType dt, QWidget* parent = nullptr);
explicit LtsCoordWidget(DisplayType dt, QWidget *parent = nullptr);
QPointF coordinate() const;
DisplayType displayType() const;
bool withResetButton() const;
bool showToolTip() const;
bool mgrsSquareEditable() const;
bool event(QEvent* event) override;
bool event(QEvent *event) override;
public Q_SLOTS:
void setCoordinate(const QPointF& geoCoord, bool bUseAsDefaultValue = true);
void setCoordinate(const QPointF &geoCoord, bool bUseAsDefaultValue = true);
void setCoordinate(double lon, double lat, bool bUseAsDefaultValue = true);
void setDisplayType(LtsCoordWidget::DisplayType dt);
void setWithResetButton(bool bWith);
void setShowToolTip(bool bShow);
void setMgrsSquareEditable(bool bEditable);
void setWithSurroundingMgrsSquares(bool bEnable);
void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate>& geoCoords);
void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate> &geoCoords);
void clear();
Q_SIGNALS:
void coordinateChanged(const QPointF& newGeoCoord);
void coordinateChanged(const QPointF &newGeoCoord);
void invalidCoordinate();
private:
@@ -60,8 +70,8 @@ class LTSCOORDWIDGET_EXPORT LtsCoordWidget : public QWidget
bool m_bShowToolTip = true;
bool m_bMgrsSquareEditable = false;
LtsCoordWidget::DisplayType m_displayType = LtsCoordWidget::DisplayType::MGRS;
LtsCoordInputWidgetHandler* m_inputWidgetHandler = nullptr;
LtsCoordInputWidgetHandler *m_inputWidgetHandler = nullptr;
QPointF m_coordinate;
QPointF m_defaultCoordinate;
};
};
} // namespace LtsCoordWidget
@@ -7,70 +7,71 @@
namespace LtsCoordWidget
{
void LtsCoordInputWidgetHandler::onCoordinateDataChanged()
{
void LtsCoordInputWidgetHandler::onCoordinateDataChanged()
{
const QPointF coord(coordinate());
if (coord.isNull())
{
emit invalidCoordinate();
return;
emit invalidCoordinate();
return;
}
emit coordinateChanged(coord);
}
}
MgrsEdit::MgrsEdit(int precision, QWidget* widget)
: LtsCoordInputWidgetHandler(widget), m_precision(precision), m_ui(new Ui::Mgrs)
{
MgrsEdit::MgrsEdit(int precision, QWidget *widget)
: LtsCoordInputWidgetHandler(widget)
, m_precision(precision)
, m_ui(new Ui::Mgrs)
{
m_ui->setupUi(widget);
if (m_precision < 0)
m_precision = 0;
m_precision = 0;
if (m_precision > 11)
m_precision = 11;
m_precision = 11;
const int upperLimit = pow(10, m_precision) - 1;
m_ui->leEast->setValidator(new QIntValidator(0, upperLimit, m_ui->leEast));
m_ui->leNorth->setValidator(new QIntValidator(0, upperLimit, m_ui->leNorth));
setDefaultMgrsSquares();
connect(m_ui->cbxZone, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
&MgrsEdit::onCoordinateDataChanged);
connect(m_ui->cbxZone, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &MgrsEdit::onCoordinateDataChanged);
connect(m_ui->leEast, &QLineEdit::editingFinished, this, &MgrsEdit::onCoordinateDataChanged);
connect(m_ui->leNorth, &QLineEdit::editingFinished, this, &MgrsEdit::onCoordinateDataChanged);
}
}
MgrsEdit::~MgrsEdit()
{
MgrsEdit::~MgrsEdit()
{
delete m_ui;
}
}
bool MgrsEdit::isValid()
{
bool MgrsEdit::isValid()
{
const QString& east = m_ui->leEast->text();
const QString &east = m_ui->leEast->text();
if (east.size() != m_precision)
return false;
return false;
const QString& north = m_ui->leNorth->text();
const QString &north = m_ui->leNorth->text();
if (north.size() != m_precision)
return false;
return false;
if (m_ui->cbxZone->currentIndex() < 0)
return false;
return false;
if (m_ui->cbxZone->currentText().isEmpty())
return false;
return false;
return true;
}
}
void MgrsEdit::setCoordinate(const QPointF& geoCoord)
{
void MgrsEdit::setCoordinate(const QPointF &geoCoord)
{
const QString mgrsString = LtsCoordTrans::mgrsFromGeographic(geoCoord.x(), geoCoord.y(), m_precision, false);
if (mgrsString.isEmpty())
{
m_ui->leEast->clear();
m_ui->leNorth->clear();
return;
m_ui->leEast->clear();
m_ui->leNorth->clear();
return;
}
m_ui->leEast->setText(QString());
@@ -82,135 +83,137 @@ void MgrsEdit::setCoordinate(const QPointF& geoCoord)
int idx = m_ui->cbxZone->findText(mgrsSquare);
if (idx < 0)
{
addMgrsSquare(mgrsSquare);
idx = m_ui->cbxZone->findText(mgrsSquare);
addMgrsSquare(mgrsSquare);
idx = m_ui->cbxZone->findText(mgrsSquare);
}
m_ui->cbxZone->setCurrentIndex(idx);
m_ui->leEast->setText(east);
m_ui->leNorth->setText(north);
}
}
static inline QString getMgrsCoord(QLineEdit* le, int prec)
{
static inline QString getMgrsCoord(QLineEdit *le, int prec)
{
QString ret = le->text();
if (ret.isEmpty())
return ret;
return ret;
while (ret.size() < prec)
ret += QLatin1Char('0');
ret += QLatin1Char('0');
le->setText(ret);
return ret;
}
}
QPointF MgrsEdit::coordinate() const
{
QPointF MgrsEdit::coordinate() const
{
const QString east = getMgrsCoord(m_ui->leEast, m_precision);
const QString north = getMgrsCoord(m_ui->leNorth, m_precision);
if (east.isEmpty() || north.isEmpty() || m_ui->cbxZone->currentIndex() < 0)
return QPointF();
return QPointF();
const QString mgrsString(m_ui->cbxZone->currentText() + east + north);
return LtsCoordTrans::geographicFromMgrs(mgrsString);
}
}
QToolButton* MgrsEdit::resetButton()
{
QToolButton *MgrsEdit::resetButton()
{
return m_ui->tbReset;
}
}
void MgrsEdit::cleanup()
{
void MgrsEdit::cleanup()
{
delete m_ui->horizontalLayout;
delete m_ui->cbxZone;
delete m_ui->leEast;
delete m_ui->leNorth;
delete m_ui->tbReset;
}
}
void MgrsEdit::clear()
{
void MgrsEdit::clear()
{
m_ui->cbxZone->clear();
m_ui->leEast->clear();
m_ui->leNorth->clear();
setDefaultMgrsSquares();
}
}
void MgrsEdit::setSquaresEditable(bool bEditable)
{
void MgrsEdit::setSquaresEditable(bool bEditable)
{
m_ui->cbxZone->setEditable(bEditable);
}
}
void MgrsEdit::setWithSurroundingSquare(bool bEnabled)
{
void MgrsEdit::setWithSurroundingSquare(bool bEnabled)
{
m_withMgrsSquareOffset = bEnabled;
}
}
static QStringList defaultMgrsSquares()
{
static QStringList defaultMgrsSquares()
{
const QVector<LtsCoordTrans::UtmCoordinate> squares(LtsCoordTrans::defaultMgrsSquares());
QStringList sl;
sl.reserve(squares.size());
for (const LtsCoordTrans::UtmCoordinate& c : squares)
sl += c.mgrs(0);
for (const LtsCoordTrans::UtmCoordinate &c : squares)
sl += c.mgrs(0);
std::sort(sl.begin(), sl.end());
return sl;
}
}
static QString preferedMgrsSquare()
{
static QString preferedMgrsSquare()
{
const LtsCoordTrans::UtmCoordinate c(LtsCoordTrans::preferedMgrsSquare());
return c.mgrs(0);
}
}
void MgrsEdit::setDefaultMgrsSquares()
{
void MgrsEdit::setDefaultMgrsSquares()
{
m_ui->cbxZone->addItems(defaultMgrsSquares());
m_ui->cbxZone->setCurrentIndex(m_ui->cbxZone->findText(preferedMgrsSquare()));
}
}
void MgrsEdit::addMgrsSquare(const QString& newMgrsSquare)
{
void MgrsEdit::addMgrsSquare(const QString &newMgrsSquare)
{
QStringList sl = defaultMgrsSquares();
sl += newMgrsSquare;
if (m_withMgrsSquareOffset)
{
QStringList squares = utmCoordsToList(LtsCoordTrans::defaultMgrsSquareWithOffsets());
QStringList squares = utmCoordsToList(LtsCoordTrans::defaultMgrsSquareWithOffsets());
for (const auto& sq : std::as_const(squares))
if (!sl.contains(sq))
sl.append(sq);
for (const auto &sq : std::as_const(squares))
if (!sl.contains(sq))
sl.append(sq);
}
std::sort(sl.begin(), sl.end());
m_ui->cbxZone->clear();
m_ui->cbxZone->addItems(sl);
}
}
QStringList MgrsEdit::utmCoordsToList(const QVector<LtsCoordTrans::UtmCoordinate>& coords)
{
QStringList MgrsEdit::utmCoordsToList(const QVector<LtsCoordTrans::UtmCoordinate> &coords)
{
QStringList list;
list.reserve(coords.count());
for (const auto& utm : coords)
list.append(utm.mgrs(0));
for (const auto &utm : coords)
list.append(utm.mgrs(0));
return list;
}
}
void MgrsEdit::setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate>& geoCoords)
{
void MgrsEdit::setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate> &geoCoords)
{
QStringList sl = utmCoordsToList(geoCoords);
if (sl.isEmpty())
return;
return;
std::sort(sl.begin(), sl.end());
m_ui->cbxZone->clear();
m_ui->cbxZone->addItems(sl);
}
}
Wgs84Edit::Wgs84Edit(QWidget* widget) : LtsCoordInputWidgetHandler(widget), m_ui(new Ui::Wgs84)
{
Wgs84Edit::Wgs84Edit(QWidget *widget)
: LtsCoordInputWidgetHandler(widget)
, m_ui(new Ui::Wgs84)
{
m_ui->setupUi(widget);
DoubleValidator* v = new DoubleValidator(-180, 180, 9, m_ui->leLon);
DoubleValidator *v = new DoubleValidator(-180, 180, 9, m_ui->leLon);
v->setNotation(QDoubleValidator::StandardNotation);
m_ui->leLon->setValidator(v);
@@ -220,50 +223,50 @@ Wgs84Edit::Wgs84Edit(QWidget* widget) : LtsCoordInputWidgetHandler(widget), m_ui
connect(m_ui->leLon, &QLineEdit::editingFinished, this, &Wgs84Edit::onCoordinateDataChanged);
connect(m_ui->leLat, &QLineEdit::editingFinished, this, &Wgs84Edit::onCoordinateDataChanged);
}
}
Wgs84Edit::~Wgs84Edit()
{
Wgs84Edit::~Wgs84Edit()
{
delete m_ui;
}
}
bool Wgs84Edit::isValid()
{
bool Wgs84Edit::isValid()
{
return (!m_ui->leLon->text().isEmpty()) && (!m_ui->leLat->text().isEmpty());
}
}
void Wgs84Edit::setCoordinate(const QPointF& geoCoord)
{
void Wgs84Edit::setCoordinate(const QPointF &geoCoord)
{
const QPointF coord(geoCoord * LtsCoordTrans::rad2deg());
const QLocale l;
m_ui->leLon->setText(l.toString(coord.x(), 'f', 9));
m_ui->leLat->setText(l.toString(coord.y(), 'f', 9));
}
}
QPointF Wgs84Edit::coordinate() const
{
QPointF Wgs84Edit::coordinate() const
{
QPointF ret;
const QLocale l;
const QString lonStr = m_ui->leLon->text().remove(l.groupSeparator());
const QString latStr = m_ui->leLat->text().remove(l.groupSeparator());
if (lonStr.isEmpty() || latStr.isEmpty())
return ret;
return ret;
ret.rx() = l.toDouble(lonStr);
ret.ry() = l.toDouble(latStr);
return ret * LtsCoordTrans::deg2rad();
}
}
QToolButton* Wgs84Edit::resetButton()
{
QToolButton *Wgs84Edit::resetButton()
{
return m_ui->tbReset;
}
}
void Wgs84Edit::cleanup()
{
void Wgs84Edit::cleanup()
{
delete m_ui->horizontalLayout;
delete m_ui->leLon;
@@ -271,31 +274,31 @@ void Wgs84Edit::cleanup()
delete m_ui->tbReset;
delete m_ui->lblLon;
delete m_ui->lblLat;
}
}
void Wgs84Edit::clear()
{
void Wgs84Edit::clear()
{
m_ui->leLon->clear();
m_ui->leLat->clear();
}
}
DoubleValidator::DoubleValidator(double bottom, double top, int decimals, QObject* parent)
: QDoubleValidator(bottom, top, decimals, parent)
{
}
DoubleValidator::DoubleValidator(double bottom, double top, int decimals, QObject *parent)
: QDoubleValidator(bottom, top, decimals, parent)
{
}
QValidator::State DoubleValidator::validate(QString& input, int& pos) const
{
QValidator::State DoubleValidator::validate(QString &input, int &pos) const
{
const QValidator::State ret = QDoubleValidator::validate(input, pos);
if (ret != QValidator::Acceptable)
return ret;
return ret;
QLocale l;
const QChar gs = l.groupSeparator().at(0);
if (gs.isNull())
return ret;
return ret;
if (input.contains(gs))
return QValidator::Invalid;
return QValidator::Invalid;
return ret;
}
}
} // namespace LtsCoordWidget
@@ -13,95 +13,89 @@
namespace LtsCoordWidget
{
class LtsCoordInputWidgetHandler : public QObject
{
class LtsCoordInputWidgetHandler : public QObject
{
Q_OBJECT
public:
explicit LtsCoordInputWidgetHandler(QObject* parent) : QObject(parent) {}
explicit LtsCoordInputWidgetHandler(QObject *parent)
: QObject(parent)
{
}
virtual bool isValid() = 0;
virtual void setCoordinate(const QPointF& geoCoord) = 0;
virtual void setCoordinate(const QPointF &geoCoord) = 0;
virtual QPointF coordinate() const = 0;
virtual QToolButton* resetButton() = 0;
virtual QToolButton *resetButton() = 0;
virtual void cleanup() = 0;
virtual void clear() = 0;
virtual void setSquaresEditable(bool bEditable) = 0;
virtual void setWithSurroundingSquare(bool bEnabled) = 0;
virtual void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate>& geoCoords) = 0;
virtual void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate> &geoCoords) = 0;
protected Q_SLOTS:
void onCoordinateDataChanged();
Q_SIGNALS:
void coordinateChanged(const QPointF& newGeoCoord);
void coordinateChanged(const QPointF &newGeoCoord);
void invalidCoordinate();
};
};
class MgrsEdit final : public LtsCoordInputWidgetHandler
{
class MgrsEdit final : public LtsCoordInputWidgetHandler
{
Q_OBJECT
public:
explicit MgrsEdit(int precision, QWidget* widget);
explicit MgrsEdit(int precision, QWidget *widget);
~MgrsEdit();
bool isValid() override;
void setCoordinate(const QPointF& geoCoord) override;
void setCoordinate(const QPointF &geoCoord) override;
QPointF coordinate() const override;
QToolButton* resetButton() override;
QToolButton *resetButton() override;
void cleanup() override;
void clear() override;
void setSquaresEditable(bool bEditable) override;
void setWithSurroundingSquare(bool bEnabled) override;
void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate>& geoCoords) override;
void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate> &geoCoords) override;
private:
void setDefaultMgrsSquares();
void addMgrsSquare(const QString& newMgrsSquare);
QStringList utmCoordsToList(const QVector<LtsCoordTrans::UtmCoordinate>& coords);
void addMgrsSquare(const QString &newMgrsSquare);
QStringList utmCoordsToList(const QVector<LtsCoordTrans::UtmCoordinate> &coords);
private:
int m_precision;
bool m_withMgrsSquareOffset = false;
Ui::Mgrs* m_ui;
};
Ui::Mgrs *m_ui;
};
class Wgs84Edit final : public LtsCoordInputWidgetHandler
{
class Wgs84Edit final : public LtsCoordInputWidgetHandler
{
Q_OBJECT
public:
explicit Wgs84Edit(QWidget* widget);
explicit Wgs84Edit(QWidget *widget);
~Wgs84Edit();
bool isValid() override;
void setCoordinate(const QPointF& geoCoord) override;
void setCoordinate(const QPointF &geoCoord) override;
QPointF coordinate() const override;
QToolButton* resetButton() override;
QToolButton *resetButton() override;
void cleanup() override;
void clear() override;
void setSquaresEditable(bool bEditable) override
{
Q_UNUSED(bEditable);
}
void setSquaresEditable(bool bEditable) override { Q_UNUSED(bEditable); }
void setWithSurroundingSquare(bool bEnabled) override
{
Q_UNUSED(bEnabled);
}
void setWithSurroundingSquare(bool bEnabled) override { Q_UNUSED(bEnabled); }
void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate>& geoCoords) override
{
Q_UNUSED(geoCoords);
}
void setMgrsSquares(const QVector<LtsCoordTrans::UtmCoordinate> &geoCoords) override { Q_UNUSED(geoCoords); }
private:
Ui::Wgs84* m_ui;
};
Ui::Wgs84 *m_ui;
};
class DoubleValidator final : public QDoubleValidator
{
class DoubleValidator final : public QDoubleValidator
{
Q_OBJECT
public:
DoubleValidator(double bottom, double top, int decimals, QObject* parent = nullptr);
DoubleValidator(double bottom, double top, int decimals, QObject *parent = nullptr);
QValidator::State validate(QString& input, int& pos) const override;
};
QValidator::State validate(QString &input, int &pos) const override;
};
} // namespace LtsCoordWidget
@@ -9,98 +9,92 @@
#include <QtWidgets/QPushButton>
#include <QtWidgets/QVBoxLayout>
static void updateLabel(const QPointF& coord, QLabel* lbl, int prec)
static void updateLabel(const QPointF &coord, QLabel *lbl, int prec)
{
QString mgrs = LtsCoordTrans::mgrsFromGeographic(coord.x(), coord.y(), prec);
QString str = QStringLiteral("mgrs: %1, lon: %2, lat: %3")
.arg(mgrs)
.arg(coord.x() * LtsCoordTrans::rad2deg(), 0, 'f', 10)
.arg(coord.y() * LtsCoordTrans::rad2deg(), 0, 'f', 10);
lbl->setText(str);
QString mgrs = LtsCoordTrans::mgrsFromGeographic(coord.x(), coord.y(), prec);
QString str =
QStringLiteral("mgrs: %1, lon: %2, lat: %3").arg(mgrs).arg(coord.x() * LtsCoordTrans::rad2deg(), 0, 'f', 10).arg(coord.y() * LtsCoordTrans::rad2deg(), 0, 'f', 10);
lbl->setText(str);
}
int main(int argc, char** argv)
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QApplication app(argc, argv);
LtsCoordTrans::UtmCoordinate base(LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32UMD00")));
QPointF topLeft(base.geographic(+50000, -50000));
QPointF bottomRight(base.geographic(-50000, 50000));
LtsCoordTrans::getMgrsSquares(QRectF(topLeft, bottomRight), true, true);
LtsCoordTrans::UtmCoordinate base(LtsCoordTrans::UtmCoordinate::fromMgrs(QStringLiteral("32UMD00")));
QPointF topLeft(base.geographic(+50000, -50000));
QPointF bottomRight(base.geographic(-50000, 50000));
LtsCoordTrans::getMgrsSquares(QRectF(topLeft, bottomRight), true, true);
QDialog* dialog(new QDialog);
QVBoxLayout* lay(new QVBoxLayout(dialog));
QDialog *dialog(new QDialog);
QVBoxLayout *lay(new QVBoxLayout(dialog));
const QPointF defCoord(QPointF(53.0, 8.0) * LtsCoordTrans::deg2rad());
const QPointF defCoord(QPointF(53.0, 8.0) * LtsCoordTrans::deg2rad());
LtsCoordWidget::LtsCoordWidget* wMgrs5(
new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS, dialog));
wMgrs5->setWithResetButton(true);
wMgrs5->setCoordinate(defCoord, true);
lay->addWidget(wMgrs5);
QLabel* lbl5(new QLabel(dialog));
lay->addWidget(lbl5);
QObject::connect(wMgrs5, &LtsCoordWidget::LtsCoordWidget::coordinateChanged, lbl5,
[lbl5](const QPointF& coord) { updateLabel(coord, lbl5, 5); });
LtsCoordWidget::LtsCoordWidget *wMgrs5(new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS, dialog));
wMgrs5->setWithResetButton(true);
wMgrs5->setCoordinate(defCoord, true);
lay->addWidget(wMgrs5);
QLabel *lbl5(new QLabel(dialog));
lay->addWidget(lbl5);
QObject::connect(wMgrs5, &LtsCoordWidget::LtsCoordWidget::coordinateChanged, lbl5, [lbl5](const QPointF &coord) { updateLabel(coord, lbl5, 5); });
LtsCoordWidget::LtsCoordWidget* wMgrs7(
new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS7, dialog));
wMgrs7->setWithResetButton(true);
wMgrs7->setCoordinate(defCoord, true);
lay->addWidget(wMgrs7);
QLabel* lbl7(new QLabel(dialog));
lay->addWidget(lbl7);
QObject::connect(wMgrs7, &LtsCoordWidget::LtsCoordWidget::coordinateChanged, wMgrs7,
[lbl7](const QPointF& coord) { updateLabel(coord, lbl7, 7); });
LtsCoordWidget::LtsCoordWidget *wMgrs7(new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS7, dialog));
wMgrs7->setWithResetButton(true);
wMgrs7->setCoordinate(defCoord, true);
lay->addWidget(wMgrs7);
QLabel *lbl7(new QLabel(dialog));
lay->addWidget(lbl7);
QObject::connect(wMgrs7, &LtsCoordWidget::LtsCoordWidget::coordinateChanged, wMgrs7, [lbl7](const QPointF &coord) { updateLabel(coord, lbl7, 7); });
LtsCoordWidget::LtsCoordWidget* w84(
new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84, dialog));
w84->setWithResetButton(true);
w84->setCoordinate(defCoord, true);
lay->addWidget(w84);
QLabel* lbl84(new QLabel(dialog));
lay->addWidget(lbl84);
QObject::connect(w84, &LtsCoordWidget::LtsCoordWidget::coordinateChanged, w84,
[lbl84](const QPointF& coord) { updateLabel(coord, lbl84, 11); });
LtsCoordWidget::LtsCoordWidget *w84(new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84, dialog));
w84->setWithResetButton(true);
w84->setCoordinate(defCoord, true);
lay->addWidget(w84);
QLabel *lbl84(new QLabel(dialog));
lay->addWidget(lbl84);
QObject::connect(w84, &LtsCoordWidget::LtsCoordWidget::coordinateChanged, w84, [lbl84](const QPointF &coord) { updateLabel(coord, lbl84, 11); });
QHBoxLayout* hLay = new QHBoxLayout;
lay->addLayout(hLay);
LtsCoordWidget::LtsCoordWidget* wChange(
new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84, dialog));
wChange->setWithResetButton(true);
wChange->setCoordinate(defCoord, true);
hLay->addWidget(wChange);
QPushButton* pbReset(new QPushButton(QStringLiteral("With Reset"), dialog));
hLay->addWidget(pbReset);
QObject::connect(pbReset, &QPushButton::clicked, wChange,
[wChange]() { wChange->setWithResetButton(!wChange->withResetButton()); });
QPushButton* pbNext(new QPushButton(QStringLiteral("Next Type"), dialog));
hLay->addWidget(pbNext);
QObject::connect(pbNext, &QPushButton::clicked, wChange, [wChange]() {
LtsCoordWidget::LtsCoordWidget::DisplayType dt = wChange->displayType();
switch (dt)
{
case LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS5:
dt = LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS7;
break;
case LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS7:
dt = LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84;
break;
case LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84:
dt = LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS5;
break;
default:
break;
}
wChange->setDisplayType(dt);
});
QHBoxLayout *hLay = new QHBoxLayout;
lay->addLayout(hLay);
LtsCoordWidget::LtsCoordWidget *wChange(new LtsCoordWidget::LtsCoordWidget(LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84, dialog));
wChange->setWithResetButton(true);
wChange->setCoordinate(defCoord, true);
hLay->addWidget(wChange);
QPushButton *pbReset(new QPushButton(QStringLiteral("With Reset"), dialog));
hLay->addWidget(pbReset);
QObject::connect(pbReset, &QPushButton::clicked, wChange, [wChange]() { wChange->setWithResetButton(!wChange->withResetButton()); });
QPushButton *pbNext(new QPushButton(QStringLiteral("Next Type"), dialog));
hLay->addWidget(pbNext);
QObject::connect(pbNext,
&QPushButton::clicked,
wChange,
[wChange]()
{
LtsCoordWidget::LtsCoordWidget::DisplayType dt = wChange->displayType();
switch (dt)
{
case LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS5:
dt = LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS7;
break;
case LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS7:
dt = LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84;
break;
case LtsCoordWidget::LtsCoordWidget::DisplayType::WGS84:
dt = LtsCoordWidget::LtsCoordWidget::DisplayType::MGRS5;
break;
default:
break;
}
wChange->setDisplayType(dt);
});
QPushButton* pb(new QPushButton(QStringLiteral("Quit"), dialog));
lay->addWidget(pb);
QObject::connect(pb, &QPushButton::clicked, qApp, QCoreApplication::quit);
QPushButton *pb(new QPushButton(QStringLiteral("Quit"), dialog));
lay->addWidget(pb);
QObject::connect(pb, &QPushButton::clicked, qApp, QCoreApplication::quit);
dialog->show();
int ret = app.exec();
delete dialog;
return ret;
dialog->show();
int ret = app.exec();
delete dialog;
return ret;
}
@@ -4,41 +4,49 @@
#include <GeographicLib/UTMUPS.hpp>
#include <string>
int main(int argc, char** argv)
int main(int argc, char **argv)
{
if (argc != 2)
{
fprintf(stderr, "Usage: %s <mgrs>\n", argv[0]);
return -1;
}
if (argc != 2)
{
fprintf(stderr, "Usage: %s <mgrs>\n", argv[0]);
return -1;
}
std::string mgrs = argv[1];
mgrs.erase(remove_if(mgrs.begin(), mgrs.end(), isspace), mgrs.end());
std::string mgrs = argv[1];
mgrs.erase(remove_if(mgrs.begin(), mgrs.end(), isspace), mgrs.end());
int prec;
double lonDeg, latDeg;
try
{
int zone;
bool northp;
double x, y;
GeographicLib::MGRS::Reverse(mgrs, zone, northp, x, y, prec, true);
GeographicLib::UTMUPS::Reverse(zone, northp, x, y, latDeg, lonDeg);
int prec;
double lonDeg, latDeg;
try
{
int zone;
bool northp;
double x, y;
GeographicLib::MGRS::Reverse(mgrs, zone, northp, x, y, prec, true);
GeographicLib::UTMUPS::Reverse(zone, northp, x, y, latDeg, lonDeg);
GeographicLib::UTMUPS::Forward(latDeg, lonDeg, zone, northp, x, y);
GeographicLib::MGRS::Forward(zone, northp, x, y, prec, mgrs);
}
catch (...)
{
fprintf(stderr, "Error converting %s to Lon/Lat coords\n", mgrs.c_str());
return -2;
}
std::string part1, part2, part3, part4;
part1 = mgrs.substr(0, 3);
part2 = mgrs.substr(3, 2);
part3 = mgrs.substr(5, prec);
part4 = mgrs.substr(5 + prec, prec);
fprintf(stdout, "%s %s %s %s = %13.10f, %13.10f ( %13.10f, %13.10f )\n", part1.c_str(), part2.c_str(),
part3.c_str(), part4.c_str(), lonDeg, latDeg, lonDeg / 180. * M_PI, latDeg / 180. * M_PI);
return 0;
GeographicLib::UTMUPS::Forward(latDeg, lonDeg, zone, northp, x, y);
GeographicLib::MGRS::Forward(zone, northp, x, y, prec, mgrs);
}
catch (...)
{
fprintf(stderr, "Error converting %s to Lon/Lat coords\n", mgrs.c_str());
return -2;
}
std::string part1, part2, part3, part4;
part1 = mgrs.substr(0, 3);
part2 = mgrs.substr(3, 2);
part3 = mgrs.substr(5, prec);
part4 = mgrs.substr(5 + prec, prec);
fprintf(stdout,
"%s %s %s %s = %13.10f, %13.10f ( %13.10f, %13.10f )\n",
part1.c_str(),
part2.c_str(),
part3.c_str(),
part4.c_str(),
lonDeg,
latDeg,
lonDeg / 180. * M_PI,
latDeg / 180. * M_PI);
return 0;
}