Apply clang-format to Lts/Common and DTC/enum headers

- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torstenandCopilot committed 2026-08-19 14:46:29 +02:00
1 parent 1881d68aef
commit d6b6ffce7c
848 files changed
+89305 -100020

No files matched your search

File diff suppressed because it is too large. Load diff
@@ -1,85 +1,60 @@
#pragma once
#include <QObject>
#include <LtsElevation/lts_elevation_manager.h>
#include <ElevationMap/elevation_map_manager.h>
#include <QCoreApplication>
#include <QtTest/QTest>
#include <LtsElevation/lts_elevation_manager.h>
#include <NGLLogger/INGLLogger.h>
#include <QCoreApplication>
#include <QObject>
#include <QtTest/QTest>
using LOGGER_T = NGL::INGLLogger&;
class UnitTestCoordinate : public QObject
{
Q_OBJECT
Q_OBJECT
public:
UnitTestCoordinate();
public:
UnitTestCoordinate();
private Q_SLOTS:
private Q_SLOTS:
void initTestCase();
void init();
void test_NaN();
void initTestCase();
void test_coordinate_simple1();
void test_coordinate_simple2();
void test_coordinate_simple3();
void test_coordinate_simple4();
void init();
void test_coordinate_fromUtm();
void test_coordinate_fromUtm2();
void test_coordinate_elevationAt();
void test_coordinate_elevationAt_isCovered();
void test_NaN();
void test_coordinate_elevation_data();
void test_coordinate_elevation();
void test_coordinate_simple1();
void test_coordinate_simple2();
void test_coordinate_simple3();
void test_coordinate_simple4();
void test_coordinate_mgrs();
void test_coordinate_fromUtm();
void test_coordinate_fromUtm2();
void test_coordinate_distance();
void test_coordinate_distanceDiffZones();
void test_coordinate_elevationAt();
void test_coordinate_elevationAt_isCovered();
void test_squareInDifferentZone();
void test_coordinate_elevation_data();
void test_coordinate_elevation();
void test_coordinate_angle();
void test_coordinate_mgrs();
void test_coordinate_cont();
void test_coordinate_distance();
void test_coordinate_distanceDiffZones();
void test_coordinate_avoid_copy();
void test_squareInDifferentZone();
void test_container_references();
void test_coordVector();
void test_coordinate_angle();
void test_coordinate_cont();
void test_coordinate_avoid_copy();
void test_container_references();
void test_coordVector();
private:
NGL::INGLLogger &m_logger;
private:
NGL::INGLLogger& m_logger;
};
+34 -55
View File
@@ -1,90 +1,69 @@
#include "lts_coord_vector.h"
namespace LtsCoordTrans
{
LtsCoordVector::LtsCoordVector(const std::vector<Core::GeoPosition> &geo_coordinates)
: m_geo_coordinates(geo_coordinates)
LtsCoordVector::LtsCoordVector(const std::vector<Core::GeoPosition>& geo_coordinates)
: m_geo_coordinates(geo_coordinates)
{
}
const std::vector<UtmCoordinate> &LtsCoordVector::toStdUtmCoord(int zone) const
const std::vector<UtmCoordinate>& LtsCoordVector::toStdUtmCoord(int zone) const
{
convertGeoToStdUtm(zone);
return m_utmMapStd[zone];
convertGeoToStdUtm(zone);
return m_utmMapStd[zone];
}
const QVector<UtmCoordinate> &LtsCoordVector::toQVectorUtmCoord(int zone) const
const QVector<UtmCoordinate>& LtsCoordVector::toQVectorUtmCoord(int zone) const
{
convertGeoToQVectorUtm(zone);
return m_utmMapQVector[zone];
convertGeoToQVectorUtm(zone);
return m_utmMapQVector[zone];
}
const QVector<QPointF> &LtsCoordVector::toQVectorQPointF(int zone) const
const QVector<QPointF>& LtsCoordVector::toQVectorQPointF(int zone) const
{
convertGeoToQVectorQPointF(zone);
return m_utmMapQVectorQPointF[zone];
convertGeoToQVectorQPointF(zone);
return m_utmMapQVectorQPointF[zone];
}
void LtsCoordVector::convertGeoToStdUtm(int zone) const
{
const auto it = m_utmMapStd.find(zone);
if (it != m_utmMapStd.end())
return;
convertGeoToUtmInternal(zone, m_utmMapStd[zone]);
const auto it = m_utmMapStd.find(zone);
if (it != m_utmMapStd.end())
return;
convertGeoToUtmInternal(zone, m_utmMapStd[zone]);
}
void LtsCoordVector::convertGeoToQVectorUtm(int zone) const
{
const auto it = m_utmMapQVector.find(zone);
if (it != m_utmMapQVector.end())
return;
const auto it = m_utmMapQVector.find(zone);
if (it != m_utmMapQVector.end())
return;
convertGeoToStdUtm(zone);
QVector<LtsCoordTrans::UtmCoordinate>& utmVectorRef = m_utmMapQVector[zone];
utmVectorRef.clear();
utmVectorRef.reserve(m_geo_coordinates.size());
convertGeoToStdUtm(zone);
QVector<LtsCoordTrans::UtmCoordinate> &utmVectorRef = m_utmMapQVector[zone];
utmVectorRef.clear();
utmVectorRef.reserve(m_geo_coordinates.size());
for (const auto &utmCoord : m_utmMapStd[zone])
utmVectorRef.push_back(utmCoord);
for (const auto& utmCoord : m_utmMapStd[zone])
utmVectorRef.push_back(utmCoord);
}
void LtsCoordVector::convertGeoToQVectorQPointF(int zone) const
{
const auto it = m_utmMapQVectorQPointF.find(zone);
if (it != m_utmMapQVectorQPointF.end())
return;
const auto it = m_utmMapQVectorQPointF.find(zone);
if (it != m_utmMapQVectorQPointF.end())
return;
convertGeoToStdUtm(zone);
QVector<QPointF> &QVectorQPointFRef = m_utmMapQVectorQPointF[zone];
QVectorQPointFRef.clear();
QVectorQPointFRef.reserve(m_geo_coordinates.size());
convertGeoToStdUtm(zone);
QVector<QPointF>& QVectorQPointFRef = m_utmMapQVectorQPointF[zone];
QVectorQPointFRef.clear();
QVectorQPointFRef.reserve(m_geo_coordinates.size());
for (const auto &utmCoord : m_utmMapStd[zone])
QVectorQPointFRef.push_back(QPointF(utmCoord.x, utmCoord.y));
for (const auto& utmCoord : m_utmMapStd[zone])
QVectorQPointFRef.push_back(QPointF(utmCoord.x, utmCoord.y));
}
}
} // namespace LtsCoordTrans
+35 -55
View File
@@ -1,82 +1,62 @@
#pragma once
#include "ltscoordinate_export.h"
#include <utility>
#include <Core/core.hpp>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <unordered_map>
#include <Core/core.hpp>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <QDebug>
#include <QPointF>
#include <QVector>
#include <QDebug>
#include <iosfwd>
#include <unordered_map>
#include <utility>
#include <vector>
namespace LtsCoordTrans
{
class LTSCOORDINATE_EXPORT LtsCoordVector
{
public:
public:
explicit LtsCoordVector(const std::vector<Core::GeoPosition>& geo_coordinates);
explicit LtsCoordVector(const std::vector<Core::GeoPosition> &geo_coordinates);
int size() const
{
return m_geo_coordinates.size();
}
int size() const { return m_geo_coordinates.size() ; }
const std::vector<Core::GeoPosition> &geoPosition() const { return m_geo_coordinates; }
const std::vector<Core::GeoPosition>& geoPosition() const
{
return m_geo_coordinates;
}
const std::vector<LtsCoordTrans::UtmCoordinate> &toStdUtmCoord(int zone) const;
const QVector<LtsCoordTrans::UtmCoordinate> &toQVectorUtmCoord(int zone) const;
const QVector<QPointF> &toQVectorQPointF(int zone) const;
const std::vector<LtsCoordTrans::UtmCoordinate>& toStdUtmCoord(int zone) const;
const QVector<LtsCoordTrans::UtmCoordinate>& toQVectorUtmCoord(int zone) const;
const QVector<QPointF>& toQVectorQPointF(int zone) const;
protected:
void convertGeoToStdUtm(int zone) const;
void convertGeoToQVectorUtm(int zone) const;
void convertGeoToQVectorQPointF(int zone) const;
protected:
void convertGeoToStdUtm(int zone) const;
void convertGeoToQVectorUtm(int zone) const;
void convertGeoToQVectorQPointF(int zone) const;
template <typename T> void convertGeoToUtmInternal(int zone, T& utmVectorRef) const
{
template<typename T>
void convertGeoToUtmInternal(int zone, T &utmVectorRef) const
{
utmVectorRef.clear();
utmVectorRef.reserve(m_geo_coordinates.size());
utmVectorRef.clear();
utmVectorRef.reserve(m_geo_coordinates.size());
for (const auto &geoCoord : std::as_const(m_geo_coordinates))
utmVectorRef.push_back(LtsCoordTrans::UtmCoordinate::fromGeographic(geoCoord.lon(), geoCoord.lat(), zone));
}
for (const auto& geoCoord : std::as_const(m_geo_coordinates))
utmVectorRef.push_back(LtsCoordTrans::UtmCoordinate::fromGeographic(geoCoord.lon(), geoCoord.lat(), zone));
}
protected:
std::vector<Core::GeoPosition> m_geo_coordinates;
protected:
std::vector<Core::GeoPosition> m_geo_coordinates;
mutable std::unordered_map<int, std::vector<LtsCoordTrans::UtmCoordinate>> m_utmMapStd;
mutable std::unordered_map<int, QVector<LtsCoordTrans::UtmCoordinate>> m_utmMapQVector;
mutable std::unordered_map<int, QVector<QPointF>> m_utmMapQVectorQPointF;
mutable std::unordered_map<int, std::vector<LtsCoordTrans::UtmCoordinate>> m_utmMapStd;
mutable std::unordered_map<int, QVector<LtsCoordTrans::UtmCoordinate>> m_utmMapQVector;
mutable std::unordered_map<int, QVector<QPointF>> m_utmMapQVectorQPointF;
};
}
} // namespace LtsCoordTrans
+72 -108
View File
@@ -1,178 +1,142 @@
#include "lts_coordinate.h"
#include <QLineF>
namespace LtsCoordTrans
{
static long s_conversion_counter = 0;
static long s_conversion_counter = 0;
std::function<double(double, double, double, bool*)> LtsCoordinate::m_getElevationCB;
void LtsCoordinate::setElevationCallback(const elevationCbFunc &elevationCB)
void LtsCoordinate::setElevationCallback(const elevationCbFunc& elevationCB)
{
m_getElevationCB = elevationCB;
m_getElevationCB = elevationCB;
}
bool LtsCoordinate::hasElevationCallback()
{
return m_getElevationCB != nullptr;
return m_getElevationCB != nullptr;
}
double LtsCoordinate::elevationAt(double defaultElevation, bool *bIsCovered) const
double LtsCoordinate::elevationAt(double defaultElevation, bool* bIsCovered) const
{
if (!bIsCovered)
if (!std::isnan(m_elevation))
return m_elevation;
if (m_getElevationCB)
m_elevation = m_getElevationCB(m_geo.lon(), m_geo.lat(), defaultElevation, bIsCovered);
return m_elevation;
if (!bIsCovered)
if (!std::isnan(m_elevation))
return m_elevation;
if (m_getElevationCB)
m_elevation = m_getElevationCB(m_geo.lon(), m_geo.lat(), defaultElevation, bIsCovered);
return m_elevation;
}
void LtsCoordinate::setZValueAccordingElevation(double defaultElevation)
{
m_geo.z(elevationAt(defaultElevation));
m_geo.z(elevationAt(defaultElevation));
}
double LtsCoordinate::elevationAt(const LtsCoordinate &coordinate, double defaultElevation, bool *bIsCovered)
double LtsCoordinate::elevationAt(const LtsCoordinate& coordinate, double defaultElevation, bool* bIsCovered)
{
return coordinate.elevationAt(defaultElevation, bIsCovered);
return coordinate.elevationAt(defaultElevation, bIsCovered);
}
void LtsCoordinate::replaceZValueByElevationIfValue(double zValueToBeReplaced, double defaultElevation)
{
if ((std::isnan(zValueToBeReplaced) && std::isnan(m_geo.z())) ||
qFuzzyCompare(m_geo.z(), zValueToBeReplaced))
setZValueAccordingElevation(defaultElevation);
if ((std::isnan(zValueToBeReplaced) && std::isnan(m_geo.z())) || qFuzzyCompare(m_geo.z(), zValueToBeReplaced))
setZValueAccordingElevation(defaultElevation);
}
double LtsCoordinate::angleDegreeUtm2D(const LtsCoordinate &coord1, const LtsCoordinate &coord2)
double LtsCoordinate::angleDegreeUtm2D(const LtsCoordinate& coord1, const LtsCoordinate& coord2)
{
const LtsCoordTrans::UtmCoordinate &utm1 = coord1.utmCoordinate();
const LtsCoordTrans::UtmCoordinate &utm2 = coord2.utmCoordinateDiffZone(utm1.zone);
const LtsCoordTrans::UtmCoordinate& utm1 = coord1.utmCoordinate();
const LtsCoordTrans::UtmCoordinate& utm2 = coord2.utmCoordinateDiffZone(utm1.zone);
const QPointF& offsetUtm = utm2.toPoint() - utm1.toPoint();
QLineF poly(QPointF(), offsetUtm);
const double angle = poly.angle();
const QPointF& offsetUtm = utm2.toPoint() - utm1.toPoint();
QLineF poly(QPointF(), offsetUtm);
const double angle = poly.angle();
return fmod(angle+90.0, 360);
return fmod(angle + 90.0, 360);
}
const UtmCoordinate &LtsCoordinate::utmCoordinateInternal(int zone) const
const UtmCoordinate& LtsCoordinate::utmCoordinateInternal(int zone) const
{
if (zone == -1)
{
if (!hasUtm())
convertGeoToUtm();
return m_utm2D;
}
utmCoordinateDiffZone(zone);
return m_utm2D_differentZone;
if (zone == -1)
{
if (!hasUtm())
convertGeoToUtm();
return m_utm2D;
}
utmCoordinateDiffZone(zone);
return m_utm2D_differentZone;
}
void LtsCoordinate::convertGeoToUtm() const
{
int zone = -1;
if (std::isnan(m_geo.lon()) || std::isnan(m_geo.lat()))
{
fprintf(stderr, "Error while fromGeographic, value is NaN\n");
m_utm2D = LtsCoordTrans::UtmCoordinate();
return;
}
int zone = -1;
if (std::isnan(m_geo.lon()) || std::isnan(m_geo.lat()))
{
fprintf(stderr, "Error while fromGeographic, value is NaN\n");
m_utm2D = LtsCoordTrans::UtmCoordinate();
return;
}
#ifdef LTS_DEBUG
++s_conversion_counter;
#endif
++s_conversion_counter;
#endif
m_utm2D = LtsCoordTrans::UtmCoordinate::fromGeographic(m_geo.lon(), m_geo.lat(), zone);
Q_ASSERT_X(m_utm2D.zone > 0, "LtsCoordinate", "zone has to be set");
m_utm2D = LtsCoordTrans::UtmCoordinate::fromGeographic(m_geo.lon(), m_geo.lat(), zone);
Q_ASSERT_X(m_utm2D.zone > 0, "LtsCoordinate", "zone has to be set");
}
QString LtsCoordinate::mgrs(int prec, bool withSpaces) const
{
utmCoordinateInternal();
QString tmp = m_utm2D.mgrs(prec, withSpaces);
return tmp;
utmCoordinateInternal();
QString tmp = m_utm2D.mgrs(prec, withSpaces);
return tmp;
}
QString LtsCoordinate::mgrsWithZ(int prec, bool withSpaces) const
{
double ele = elevationAt();
QString tmp = mgrs(prec, withSpaces) + QStringLiteral(" z=") + QString::number(ele, 'f', 2);
return tmp;
double ele = elevationAt();
QString tmp = mgrs(prec, withSpaces) + QStringLiteral(" z=") + QString::number(ele, 'f', 2);
return tmp;
}
QString LtsCoordinate::toString(bool fullAndExpensive) const
{
if (fullAndExpensive)
{
utmCoordinateInternal();
elevationAt();
}
std::ostringstream stream;
stream << "LtsCoordinate(m_geo=" << m_geo
<< ", m_utm2D.x " << m_utm2D.x << ", m_utm2D.y " << m_utm2D.y << ", m_utm2D.zone " << m_utm2D.zone;
if (!qFuzzyIsNull(m_utm2D.x) || !qFuzzyIsNull(m_utm2D.y))
stream << ", m_utm2D.mgrs '" << m_utm2D.mgrs().toUtf8().constData() << "'";
stream << ", elevation " << std::fixed << std::setprecision(3) << m_elevation
<< ")";
return QString::fromStdString(stream.str());
if (fullAndExpensive)
{
utmCoordinateInternal();
elevationAt();
}
std::ostringstream stream;
stream << "LtsCoordinate(m_geo=" << m_geo << ", m_utm2D.x " << m_utm2D.x << ", m_utm2D.y " << m_utm2D.y
<< ", m_utm2D.zone " << m_utm2D.zone;
if (!qFuzzyIsNull(m_utm2D.x) || !qFuzzyIsNull(m_utm2D.y))
stream << ", m_utm2D.mgrs '" << m_utm2D.mgrs().toUtf8().constData() << "'";
stream << ", elevation " << std::fixed << std::setprecision(3) << m_elevation << ")";
return QString::fromStdString(stream.str());
}
void LtsCoordinate::resetConversionCounter()
{
s_conversion_counter = 0;
s_conversion_counter = 0;
}
long LtsCoordinate::getConversionCounter()
{
return s_conversion_counter;
return s_conversion_counter;
}
std::ostream &operator<<(std::ostream &stream, const LtsCoordinate &value)
std::ostream& operator<<(std::ostream& stream, const LtsCoordinate& value)
{
stream << value.toString().toStdString();
return stream;
stream << value.toString().toStdString();
return stream;
}
}
} // namespace LtsCoordTrans
+212 -283
View File
@@ -1,368 +1,297 @@
#pragma once
#include "ltscoordinate_export.h"
#include <utility>
#include <Core/core.hpp>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <LtsUtils/LtsUtilsCore/qpoint3d.h>
#include <QPointF>
#include <Core/core.hpp>
#include <LtsCoordTrans/lts_coord_trans.h>
#include <LtsUtils/LtsUtilsCore/qpoint3d.h>
#include <QDebug>
#include <functional>
#include <QPointF>
#include <functional>
#include <iosfwd>
#include <type_traits>
#include <type_traits>
#include <utility>
namespace LtsCoordTrans
{
using UtmCoordinate2D = LtsCoordTrans::UtmCoordinate;
using QPoint3D = LtsUtils::QPoint3D;
using QPoint3D = LtsUtils::QPoint3D;
class LTSCOORDINATE_EXPORT LtsCoordinate
{
public:
public:
explicit LtsCoordinate(double lon = 0, double lat = 0, double z = std::nan(""))
: m_geo(Core::GeoPosition(lon, lat, z))
{
}
explicit LtsCoordinate(const QPointF& lonLat, double z = std::nan(""))
: m_geo(Core::GeoPosition(lonLat.x(), lonLat.y(), z))
{
}
explicit LtsCoordinate(double lon = 0, double lat = 0, double z = std::nan(""))
: m_geo(Core::GeoPosition(lon, lat, z))
{}
explicit LtsCoordinate(const Core::GeoPosition& geoPos) : m_geo(geoPos) {}
explicit LtsCoordinate(const QPointF &lonLat, double z = std::nan(""))
: m_geo(Core::GeoPosition(lonLat.x(), lonLat.y(), z))
{}
explicit LtsCoordinate(const Core::GeoPosition2D& geoPos2D) : m_geo(geoPos2D.lon(), geoPos2D.lat(), std::nan("")) {}
explicit LtsCoordinate(const Core::GeoPosition &geoPos)
: m_geo(geoPos)
{}
LtsCoordinate(const LtsCoordTrans::UtmCoordinate& utm2D, double zValue) = delete;
explicit LtsCoordinate(const Core::GeoPosition2D &geoPos2D)
: m_geo(geoPos2D.lon(), geoPos2D.lat(), std::nan(""))
{}
static LtsCoordinate fromGeoPosition(double lon, double lat, double z = std::nan(""))
{
return LtsCoordinate(lon, lat, z);
}
LtsCoordinate(const LtsCoordTrans::UtmCoordinate &utm2D, double zValue) = delete;
static LtsCoordinate fromUtmCoordinate(const LtsCoordTrans::UtmCoordinate& utm2D, double zValue)
{
Q_ASSERT_X(utm2D.zone > 0, "LtsCoordinate", "zone has to be set");
static LtsCoordinate fromGeoPosition(double lon, double lat, double z = std::nan(""))
{
return LtsCoordinate(lon, lat, z);
}
const QPointF& geoPnt = utm2D.geographic();
static LtsCoordinate fromUtmCoordinate(const LtsCoordTrans::UtmCoordinate &utm2D, double zValue)
{
Q_ASSERT_X(utm2D.zone > 0, "LtsCoordinate", "zone has to be set");
return LtsCoordinate(geoPnt.x(), geoPnt.y(), zValue);
}
const QPointF &geoPnt = utm2D.geographic();
return LtsCoordinate(geoPnt.x(), geoPnt.y(), zValue);
}
static LtsCoordinate fromUtm(const QPointF& utm2d, int zone, double zValue)
{
const LtsCoordTrans::UtmCoordinate utmCoord(zone, utm2d.x(), utm2d.y());
const QPointF& geoPnt = utmCoord.geographic();
return LtsCoordinate(geoPnt.x(), geoPnt.y(), zValue);
}
static LtsCoordinate fromUtm(const QPointF &utm2d, int zone, double zValue)
{
const LtsCoordTrans::UtmCoordinate utmCoord(zone, utm2d.x(), utm2d.y());
const QPointF &geoPnt = utmCoord.geographic();
return LtsCoordinate(geoPnt.x(), geoPnt.y(), zValue);
}
bool isValid() const
{
return hasGeo() || hasUtm();
}
bool hasGeo() const
{
return !(valueIsNullOrNan(m_geo.lon()) || valueIsNullOrNan(m_geo.lat()));
}
bool hasUtm() const
{
return m_utm2D.isValid();
}
bool isValid() const { return hasGeo() || hasUtm(); }
bool hasGeo() const { return !(valueIsNullOrNan(m_geo.lon()) ||
valueIsNullOrNan(m_geo.lat())); }
bool hasUtm() const { return m_utm2D.isValid(); }
static bool valueIsNullOrNan(double value)
{
return qFuzzyIsNull(value) || std::isnan(value);
}
static bool valueIsNullOrNan(double value) { return qFuzzyIsNull(value) || std::isnan(value); }
QString mgrs(int prec = 5, bool withSpaces = true) const;
QString mgrsWithZ(int prec = 5, bool withSpaces = true) const;
QString mgrs(int prec = 5, bool withSpaces = true) const;
QString mgrsWithZ(int prec = 5, bool withSpaces = true) const;
QString toString(bool fullAndExpensive = false) const;
QString toString(bool fullAndExpensive = false) const;
static void resetConversionCounter();
static long getConversionCounter();
const Core::GeoPosition& geoPosition() const
{
return m_geo;
}
static void resetConversionCounter();
static long getConversionCounter();
const Core::GeoPosition2D& geoPosition2D() const
{
return m_geo;
}
const LtsCoordTrans::UtmCoordinate& utmCoordinate() const
{
if (!hasUtm())
convertGeoToUtm();
return m_utm2D;
}
const Core::GeoPosition &geoPosition() const
{
return m_geo;
}
const Core::GeoPosition2D &geoPosition2D() const
{
return m_geo;
}
double& rz()
{
return m_geo.z();
}
const LtsCoordTrans::UtmCoordinate &utmCoordinate() const
{
if (!hasUtm())
convertGeoToUtm();
return m_utm2D;
}
double z() const
{
return m_geo.z();
}
double &rz() { return m_geo.z(); }
double z() const { return m_geo.z(); }
void setZ(double value) { m_geo.z(value); }
void setZ(double value)
{
m_geo.z(value);
}
LtsCoordTrans::UtmCoordinate utmCoordinateDiffZone(int zone) const
{
LtsCoordTrans::UtmCoordinate utmCoordinateDiffZone(int zone) const
{
m_utm2D_differentZone = LtsCoordTrans::UtmCoordinate::fromGeographic(m_geo.lon(), m_geo.lat(), zone);
return m_utm2D_differentZone;
}
m_utm2D_differentZone = LtsCoordTrans::UtmCoordinate::fromGeographic(m_geo.lon(), m_geo.lat(), zone);
return m_utm2D_differentZone;
}
template <typename T> T toUtm(int zone = -1) const
{
T obj;
helperToUtm(obj, zone);
return obj;
}
template<typename T>
T toUtm(int zone = -1) const
{
T obj;
helperToUtm(obj, zone);
return obj;
QPointF toUtmPointF() const
{
return toUtm<QPointF>();
}
}
QPoint3D toUtmPoint3D() const
{
return toUtm<QPoint3D>();
}
QPointF toUtmPointF() const { return toUtm<QPointF>(); }
QPoint3D toUtmPoint3D() const { return toUtm<QPoint3D>(); }
QPointF toGeoPointF() const
{
return QPointF(m_geo.lon(), m_geo.lat());
}
QPointF toGeoPointF() const { return QPointF (m_geo.lon(), m_geo.lat()); }
QPoint3D toGeoPoint3D() const { return QPoint3D(m_geo.lon(), m_geo.lat(), m_geo.z() ); }
QPoint3D toGeoPoint3D() const
{
return QPoint3D(m_geo.lon(), m_geo.lat(), m_geo.z());
}
UtmCoordinate3D toUtmCoordinate3D() const
{
return UtmCoordinate3D(utmCoordinate(), m_geo.z());
}
UtmCoordinate3D toUtmCoordinate3D() const
{
return UtmCoordinate3D(utmCoordinate(), m_geo.z());
}
using elevationCbFunc = std::function<double(double, double, double, bool*)>;
static void setElevationCallback(const elevationCbFunc& elevationCB);
static bool hasElevationCallback();
using elevationCbFunc = std::function<double(double, double, double, bool*)>;
double elevationAt(double defaultElevation = 0.0, bool* bIsCovered = nullptr) const;
void setZValueAccordingElevation(double defaultElevation = 0.0);
static void setElevationCallback(const elevationCbFunc &elevationCB);
static bool hasElevationCallback();
static double elevationAt(const LtsCoordinate& coordinate, double defaultElevation = 0.0,
bool* bIsCovered = nullptr);
double elevationAt(double defaultElevation = 0.0, bool *bIsCovered = nullptr) const;
void setZValueAccordingElevation(double defaultElevation = 0.0);
void replaceZValueByElevationIfValue(double zValueToBeReplaced = std::nan(""), double defaultElevation = 0.0);
static double elevationAt(const LtsCoordinate &coordinate, double defaultElevation = 0.0, bool *bIsCovered = nullptr);
double heightOverElevation() const
{
return m_geo.z() - elevationAt();
}
double distanceUtm2D(const LtsCoordinate& other) const
{
const LtsCoordTrans::UtmCoordinate& thisUtm2D = utmCoordinate();
const LtsCoordTrans::UtmCoordinate& otherUtm2D = other.utmCoordinateDiffZone(m_utm2D.zone);
return LtsCoordTrans::distance(thisUtm2D, otherUtm2D);
}
void replaceZValueByElevationIfValue(double zValueToBeReplaced = std::nan(""), double defaultElevation = 0.0);
double distanceUtm3D(const LtsCoordinate& other) const
{
const QPoint3D& thisUtm3D = toUtm<QPoint3D>();
const QPoint3D& otherUtm3D = other.toUtm<QPoint3D>(m_utm2D.zone);
const double dist3D = (thisUtm3D - otherUtm3D).length();
Q_ASSERT_X(!std::isnan(dist3D), "LtsCoordinate", "ERROR, distance3D is NaN");
return dist3D;
}
static double angleDegreeUtm2D(const LtsCoordinate& coord1, const LtsCoordinate& coord2);
double heightOverElevation() const { return m_geo.z() - elevationAt(); }
protected:
void clearGeo() const
{
clearGeoLonLat();
m_geo.z(std::nan(""));
}
void clearGeoLonLat() const
{
m_geo.lon(0);
m_geo.lat(0);
}
double distanceUtm2D(const LtsCoordinate &other) const
{
const LtsCoordTrans::UtmCoordinate &thisUtm2D = utmCoordinate();
const LtsCoordTrans::UtmCoordinate &otherUtm2D = other.utmCoordinateDiffZone(m_utm2D.zone);
return LtsCoordTrans::distance(thisUtm2D, otherUtm2D);
}
void clearUtm() const
{
m_utm2D = m_utm2D_differentZone = UtmCoordinate2D();
}
double distanceUtm3D(const LtsCoordinate &other) const
{
const QPoint3D &thisUtm3D = toUtm<QPoint3D>();
const QPoint3D &otherUtm3D = other.toUtm<QPoint3D>(m_utm2D.zone);
const double dist3D = (thisUtm3D - otherUtm3D).length();
void clearElevation() const
{
m_elevation = std::nan("");
}
Q_ASSERT_X(!std::isnan(dist3D), "LtsCoordinate", "ERROR, distance3D is NaN");
void clear() const
{
clearGeo();
clearUtm();
clearElevation();
}
return dist3D;
}
const LtsCoordTrans::UtmCoordinate& utmCoordinateInternal(int zone = -1) const;
void convertGeoToUtm() const;
static double angleDegreeUtm2D(const LtsCoordinate &coord1, const LtsCoordinate &coord2);
protected:
void helperToUtm(QPointF& pntRef, int zone = -1) const
{
const auto& utmTemp = utmCoordinateInternal(zone);
pntRef.rx() = utmTemp.x;
pntRef.ry() = utmTemp.y;
}
void helperToUtm(QPoint3D& pntRef, int zone = -1) const
{
const auto& utmTemp = utmCoordinateInternal(zone);
pntRef.rx() = utmTemp.x;
pntRef.ry() = utmTemp.y;
pntRef.rz() = m_geo.z();
}
protected:
mutable Core::GeoPosition m_geo;
mutable UtmCoordinate2D m_utm2D;
mutable UtmCoordinate2D m_utm2D_differentZone;
mutable double m_elevation{std::nan("")};
protected:
void clearGeo() const { clearGeoLonLat(); m_geo.z(std::nan("")); }
void clearGeoLonLat() const { m_geo.lon(0); m_geo.lat(0); }
void clearUtm() const { m_utm2D = m_utm2D_differentZone = UtmCoordinate2D(); }
void clearElevation() const { m_elevation = std::nan(""); }
void clear() const { clearGeo(); clearUtm(); clearElevation(); }
const LtsCoordTrans::UtmCoordinate &utmCoordinateInternal(int zone = -1) const;
void convertGeoToUtm() const;
protected:
void helperToUtm(QPointF &pntRef, int zone = -1) const
{
const auto &utmTemp = utmCoordinateInternal(zone);
pntRef.rx() = utmTemp.x;
pntRef.ry() = utmTemp.y;
}
void helperToUtm(QPoint3D &pntRef, int zone = -1) const
{
const auto &utmTemp = utmCoordinateInternal(zone);
pntRef.rx() = utmTemp.x;
pntRef.ry() = utmTemp.y;
pntRef.rz() = m_geo.z();
}
protected:
mutable Core::GeoPosition m_geo;
mutable UtmCoordinate2D m_utm2D;
mutable UtmCoordinate2D m_utm2D_differentZone;
mutable double m_elevation{std::nan("")};
static elevationCbFunc m_getElevationCB;
static elevationCbFunc m_getElevationCB;
};
class LTSCOORDINATE_EXPORT LtsCoordinateNoImplicitCopy : public LtsCoordinate
{
public:
using BaseClass = LtsCoordinate;
public:
using BaseClass = LtsCoordinate;
LtsCoordinateNoImplicitCopy() = default;
explicit LtsCoordinateNoImplicitCopy(const LtsCoordinateNoImplicitCopy&) = default;
LtsCoordinateNoImplicitCopy() = default;
explicit LtsCoordinateNoImplicitCopy (const LtsCoordinateNoImplicitCopy &) = default;
~LtsCoordinateNoImplicitCopy() = default;
explicit LtsCoordinateNoImplicitCopy(const QPointF& lonLat, double z = std::nan(""))
: BaseClass(Core::GeoPosition(lonLat.x(), lonLat.y(), z))
{
}
~LtsCoordinateNoImplicitCopy() = default;
explicit LtsCoordinateNoImplicitCopy(const Core::GeoPosition& geoPos) : BaseClass(geoPos) {}
explicit LtsCoordinateNoImplicitCopy(const Core::GeoPosition2D& geoPos2D) : BaseClass(geoPos2D) {}
explicit LtsCoordinateNoImplicitCopy(const QPointF &lonLat, double z = std::nan(""))
: BaseClass(Core::GeoPosition(lonLat.x(), lonLat.y(), z))
{}
explicit LtsCoordinateNoImplicitCopy(const Core::GeoPosition &geoPos)
: BaseClass(geoPos)
{}
explicit LtsCoordinateNoImplicitCopy(const Core::GeoPosition2D &geoPos2D)
: BaseClass(geoPos2D)
{}
void updateGeoPosition(const Core::GeoPosition &geoPos) const
{
clear();
m_geo = geoPos;
}
void updateGeoPosition(const Core::GeoPosition& geoPos) const
{
clear();
m_geo = geoPos;
}
};
template<typename T_OUT, typename T_IN>
T_OUT convert(const T_IN& contIn)
template <typename T_OUT, typename T_IN> T_OUT convert(const T_IN& contIn)
{
T_OUT out;
out.reserve(contIn.size());
for (const Core::GeoPosition &posGeo : std::as_const(contIn))
out.push_back(LtsCoordinate(posGeo));
return out;
T_OUT out;
out.reserve(contIn.size());
for (const Core::GeoPosition& posGeo : std::as_const(contIn))
out.push_back(LtsCoordinate(posGeo));
return out;
}
LTSCOORDINATE_EXPORT std::ostream& operator<<(std::ostream& stream, const LtsCoordinate& value);
LTSCOORDINATE_EXPORT std::ostream &operator<< (std::ostream &stream,
const LtsCoordinate &value);
}
} // namespace LtsCoordTrans