Terrain unit test back on (#9257)

* Cleanup for better readability

* Turn follow terrain unit test back one

src/MissionManager/TransectStyleComplexItemTest.cc

@@ -80,7 +80,7 @@ void TransectStyleComplexItemTest::_testDirty(void)
     }
     rgFacts.clear();
 
-    _transectStyleItem->_adjustSurveAreaPolygon();
+    _transectStyleItem->adjustSurveAreaPolygon();
     QVERIFY(_transectStyleItem->dirty());
     _transectStyleItem->setDirty(false);
     QVERIFY(!_transectStyleItem->surveyAreaPolygon()->dirty());
@@ -99,7 +99,7 @@ void TransectStyleComplexItemTest::_testRebuildTransects(void)
     //  _rebuildTransects calls
     //  coveredAreaChanged signal
     //  lastSequenceNumberChanged signal
-    _transectStyleItem->_adjustSurveAreaPolygon();
+    _transectStyleItem->adjustSurveAreaPolygon();
     QVERIFY(_transectStyleItem->rebuildTransectsPhase1Called);
     QVERIFY(_transectStyleItem->recalcCameraShotsCalled);
     // FIXME: Temproarily not possible
@@ -164,7 +164,7 @@ void TransectStyleComplexItemTest::_testRebuildTransects(void)
 
 void TransectStyleComplexItemTest::_testDistanceSignalling(void)
 {
-    _transectStyleItem->_adjustSurveAreaPolygon();
+    _transectStyleItem->adjustSurveAreaPolygon();
     QVERIFY(_multiSpy->checkSignalsByMask(complexDistanceChangedMask | greatestDistanceToChangedMask));
     _transectStyleItem->setDirty(false);
     _multiSpy->clearAllSignals();
@@ -209,27 +209,25 @@ void TransectStyleComplexItemTest::_testAltMode(void)
     QVERIFY(!_transectStyleItem->followTerrain());
 }
 
-#if 0
-// Temporarily disabled
 void TransectStyleComplexItemTest::_testFollowTerrain(void) {
-    _multiSpy->clearAllSignals();
     _transectStyleItem->cameraCalc()->distanceToSurface()->setRawValue(50);
+    _transectStyleItem->cameraCalc()->adjustedFootprintFrontal()->setRawValue(0);
     _transectStyleItem->setFollowTerrain(true);
-    _multiSpy->clearAllSignals();
-    while(_transectStyleItem->readyForSaveState() != TransectStyleComplexItem::ReadyForSave) {
-        QVERIFY(_multiSpy->waitForSignalByIndex(lastSequenceNumberChangedIndex, 50));
-    }
-    QList<double> expectedTerrainValues{497,509,512,512};
-    QCOMPARE(_transectStyleItem->transects().size(), 1);
-    for (const auto& transect : _transectStyleItem->transects()) {
-        QCOMPARE(transect.size(), 4);
-        for (const auto& pt : transect) {
-            QCOMPARE(pt.coord.altitude(), expectedTerrainValues.front());
-            expectedTerrainValues.pop_front();
-        }
+
+    QVERIFY(QTest::qWaitFor([&]() { return _transectStyleItem->readyForSaveState() == TransectStyleComplexItem::ReadyForSave; }, 2000));
+
+    QList<MissionItem*> rgItems;
+    _transectStyleItem->appendMissionItems(rgItems, this);
+
+    QList<double> expectedTerrainValues {497, 509, 512, 512 };
+    //QCOMPARE(rgItems.count(), expectedTerrainValues.count());
+    for (const MissionItem* missionItem : rgItems) {
+        QCOMPARE(missionItem->command(), MAV_CMD_NAV_WAYPOINT);
+        QCOMPARE(missionItem->frame(), MAV_FRAME_GLOBAL);
+        QCOMPARE(missionItem->param7(), expectedTerrainValues.front());
+        expectedTerrainValues.pop_front();
     }
 }
-#endif
 
 TestTransectStyleItem::TestTransectStyleItem(PlanMasterController* masterController, QObject* parent)
     : TransectStyleComplexItem      (masterController, false /* flyView */, QStringLiteral("UnitTestTransect"), parent)
@@ -243,15 +241,21 @@ TestTransectStyleItem::TestTransectStyleItem(PlanMasterController* masterControl
     surveyAreaPolygon()->appendVertex(surveyAreaPolygon()->vertexCoordinate(0).atDistanceAndAzimuth(edgeDistance, 90));
     surveyAreaPolygon()->appendVertex(surveyAreaPolygon()->vertexCoordinate(1).atDistanceAndAzimuth(edgeDistance, 180));
     surveyAreaPolygon()->appendVertex(surveyAreaPolygon()->vertexCoordinate(2).atDistanceAndAzimuth(edgeDistance, -90.0));
-    _transects.append(QList<TransectStyleComplexItem::CoordInfo_t>{
-        {surveyAreaPolygon()->vertexCoordinate(0), CoordTypeSurveyEntry},
-        {surveyAreaPolygon()->vertexCoordinate(2), CoordTypeSurveyExit}}
-    );
 }
 
 void TestTransectStyleItem::_rebuildTransectsPhase1(void)
 {
     rebuildTransectsPhase1Called = true;
+
+    _transects.clear();
+    if (_surveyAreaPolygon.count() < 3) {
+        return;
+    }
+
+    _transects.append(QList<TransectStyleComplexItem::CoordInfo_t>{
+        {surveyAreaPolygon()->vertexCoordinate(0), CoordTypeSurveyEntry},
+        {surveyAreaPolygon()->vertexCoordinate(2), CoordTypeSurveyExit}}
+    );
 }
 
 void TestTransectStyleItem::_recalcCameraShots(void)
@@ -259,7 +263,7 @@ void TestTransectStyleItem::_recalcCameraShots(void)
     recalcCameraShotsCalled = true;
 }
 
-void TestTransectStyleItem::_adjustSurveAreaPolygon(void)
+void TestTransectStyleItem::adjustSurveAreaPolygon(void)
 {
     QGeoCoordinate vertex = surveyAreaPolygon()->vertexCoordinate(0);
     vertex.setLatitude(vertex.latitude() + 1);

src/MissionManager/TransectStyleComplexItemTest.h

@@ -34,7 +34,7 @@ private slots:
     void _testRebuildTransects  (void);
     void _testDistanceSignalling(void);
     void _testAltMode           (void);
-    //void _testFollowTerrain     (void);
+    void _testFollowTerrain     (void);
 
 private:
     enum {
@@ -82,6 +82,8 @@ class TestTransectStyleItem : public TransectStyleComplexItem
 public:
     TestTransectStyleItem(PlanMasterController* masterController, QObject* parent = nullptr);
 
+    void adjustSurveAreaPolygon(void);
+
     // Overrides from ComplexMissionItem
     QString patternName         (void) const final { return QString(); }
     QString mapVisualQML        (void) const final { return QString(); }
@@ -95,10 +97,6 @@ public:
     bool rebuildTransectsPhase1Called;
     bool recalcComplexDistanceCalled;
     bool recalcCameraShotsCalled;
-    void _adjustSurveAreaPolygon(void);
-    QList<QList<CoordInfo_t>> transects() const {
-        return _transects;
-    }
 
 private slots:
     // Overrides from TransectStyleComplexItem

src/QtLocationPlugin/QGCMapTileSet.cpp

@@ -292,7 +292,7 @@ QGCCachedTileSet::_networkReplyFinished()
             QByteArray image = reply->readAll();
             QString type = getQGCMapEngine()->hashToType(hash);
             if (type == "Airmap Elevation" ) {
-                image = TerrainTile::serialize(image);
+                image = TerrainTile::serializeFromAirMapJson(image);
             }
             QString format = getQGCMapEngine()->urlFactory()->getImageFormat(type, image);
             if(!format.isEmpty()) {

src/QtLocationPlugin/QGeoMapReplyQGC.cpp

@@ -133,7 +133,7 @@ QGeoTiledMapReplyQGC::networkReplyFinished()
     QString format = urlFactory->getImageFormat(tileSpec().mapId(), a);
     //-- Test for a specialized, elevation data (not map tile)
     if( getQGCMapEngine()->urlFactory()->isElevation(tileSpec().mapId())){
-        a = TerrainTile::serialize(a);
+        a = TerrainTile::serializeFromAirMapJson(a);
         //-- Cache it if valid
         if(!a.isEmpty()) {
             getQGCMapEngine()->cacheTile(

src/Terrain/TerrainQuery.cc

@@ -364,35 +364,45 @@ void TerrainTileManager::addCoordinateQuery(TerrainOfflineAirMapQuery* terrainQu
     }
 }
 
-void TerrainTileManager::addPathQuery(TerrainOfflineAirMapQuery* terrainQueryInterface, const QGeoCoordinate &startPoint, const QGeoCoordinate &endPoint)
+/// Returns a list of individual coordinates along the requested path spaced according to the terrain tile value spacing
+QList<QGeoCoordinate> TerrainTileManager::pathQueryToCoords(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord, double& distanceBetween, double& finalDistanceBetween)
 {
-    // Convert to individual coordinate queries
     QList<QGeoCoordinate> coordinates;
-    double lat = startPoint.latitude();
-    double lon = startPoint.longitude();
-    double steps = ceil(endPoint.distanceTo(startPoint) / TerrainTile::tileValueSpacingMeters);
-    double latDiff = endPoint.latitude() - lat;
-    double lonDiff = endPoint.longitude() - lon;
 
-    double distanceBetween;
-    double finalDistanceBetween;
+    double lat      = fromCoord.latitude();
+    double lon      = fromCoord.longitude();
+    double steps    = qCeil(toCoord.distanceTo(fromCoord) / TerrainTile::tileValueSpacingMeters);
+    double latDiff  = toCoord.latitude() - lat;
+    double lonDiff  = toCoord.longitude() - lon;
+
     if (steps == 0) {
-        coordinates.append(startPoint);
-        coordinates.append(endPoint);
+        coordinates.append(fromCoord);
+        coordinates.append(toCoord);
         distanceBetween = finalDistanceBetween = coordinates[0].distanceTo(coordinates[1]);
     } else {
         for (double i = 0.0; i <= steps; i = i + 1) {
             coordinates.append(QGeoCoordinate(lat + latDiff * i / steps, lon + lonDiff * i / steps));
         }
         // We always have one too many and we always want the last one to be the endpoint
-        coordinates.last() = endPoint;
+        coordinates.last() = toCoord;
         distanceBetween = coordinates[0].distanceTo(coordinates[1]);
         finalDistanceBetween = coordinates[coordinates.count() - 2].distanceTo(coordinates.last());
     }
 
     //qDebug() << "terrain" << startPoint.distanceTo(endPoint) << coordinates.count() << distanceBetween;
 
-    qCDebug(TerrainQueryLog) << "TerrainTileManager::addPathQuery start:end:coordCount" << startPoint << endPoint << coordinates.count();
+    qCDebug(TerrainQueryLog) << "TerrainTileManager::pathQueryToCoords fromCoord:toCoord:distanceBetween:finalDisanceBetween:coordCount" << fromCoord << toCoord << distanceBetween << finalDistanceBetween << coordinates.count();
+
+    return coordinates;
+}
+
+void TerrainTileManager::addPathQuery(TerrainOfflineAirMapQuery* terrainQueryInterface, const QGeoCoordinate &startPoint, const QGeoCoordinate &endPoint)
+{
+    QList<QGeoCoordinate> coordinates;
+    double distanceBetween;
+    double finalDistanceBetween;
+
+    coordinates = pathQueryToCoords(startPoint, endPoint, distanceBetween, finalDistanceBetween);
 
     bool error;
     QList<double> altitudes;
@@ -797,116 +807,105 @@ void TerrainPolyPathQuery::_terrainDataReceived(bool success, const TerrainPathQ
     }
 }
 
-
-
 const QGeoCoordinate UnitTestTerrainQuery::pointNemo{-48.875556, -123.392500};
 const UnitTestTerrainQuery::Flat10Region UnitTestTerrainQuery::flat10Region{{
       pointNemo,
       QGeoCoordinate{
-          pointNemo.latitude() - UnitTestTerrainQuery::regionExtentDeg,
-          pointNemo.longitude() + UnitTestTerrainQuery::regionExtentDeg
+          pointNemo.latitude() - UnitTestTerrainQuery::regionSizeDeg,
+          pointNemo.longitude() + UnitTestTerrainQuery::regionSizeDeg
       }
 }};
-const double UnitTestTerrainQuery::Flat10Region::elevationMts = 10;
+const double UnitTestTerrainQuery::Flat10Region::amslElevation = 10;
 
 const UnitTestTerrainQuery::LinearSlopeRegion UnitTestTerrainQuery::linearSlopeRegion{{
     flat10Region.topRight(),
     QGeoCoordinate{
-        flat10Region.topRight().latitude() - UnitTestTerrainQuery::regionExtentDeg,
-        flat10Region.topRight().longitude() + UnitTestTerrainQuery::regionExtentDeg
+        flat10Region.topRight().latitude() - UnitTestTerrainQuery::regionSizeDeg,
+        flat10Region.topRight().longitude() + UnitTestTerrainQuery::regionSizeDeg
     }
 }};
-const double UnitTestTerrainQuery::LinearSlopeRegion::minElevationMts = -100;
-const double UnitTestTerrainQuery::LinearSlopeRegion::maxElevationMts = 1000;
-const double UnitTestTerrainQuery::LinearSlopeRegion::dElevationMts   = maxElevationMts-minElevationMts;
+const double UnitTestTerrainQuery::LinearSlopeRegion::minAMSLElevation  = -100;
+const double UnitTestTerrainQuery::LinearSlopeRegion::maxAMSLElevation  = 1000;
+const double UnitTestTerrainQuery::LinearSlopeRegion::totalElevationChange     = maxAMSLElevation - minAMSLElevation;
 
 UnitTestTerrainQuery::UnitTestTerrainQuery(TerrainQueryInterface* parent)
-:TerrainQueryInterface(parent)
-{}
+    :TerrainQueryInterface(parent)
+{
+
+}
 
 void UnitTestTerrainQuery::requestCoordinateHeights(const QList<QGeoCoordinate>& coordinates) {
-    QList<double> result = requestCoordinateHeightsSync(coordinates);
+    QList<double> result = _requestCoordinateHeights(coordinates);
     emit qobject_cast<TerrainQueryInterface*>(parent())->coordinateHeightsReceived(result.size() == coordinates.size(), result);
 }
 
 void UnitTestTerrainQuery::requestPathHeights(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord) {
-    QPair<QList<QGeoCoordinate>, QList<double>> result = requestPathHeightsSync(fromCoord, toCoord);
+    auto pathHeightInfo = _requestPathHeights(fromCoord, toCoord);
     emit qobject_cast<TerrainQueryInterface*>(parent())->pathHeightsReceived(
-        result.second.size() > 0,
-        result.first[0].distanceTo(result.first[1]),
-        result.first[result.first.size()-2].distanceTo(result.first.back()),
-        result.second
+        pathHeightInfo.rgHeights.count() > 0,
+        pathHeightInfo.distanceBetween,
+        pathHeightInfo.finalDistanceBetween,
+        pathHeightInfo.rgHeights
     );
 }
 
 void UnitTestTerrainQuery::requestCarpetHeights(const QGeoCoordinate& swCoord, const QGeoCoordinate& neCoord, bool) {
-    assert(swCoord.longitude() < neCoord.longitude());
-    assert(swCoord.latitude() < neCoord.latitude());
+    QList<QList<double>> carpet;
+
+    if (swCoord.longitude() > neCoord.longitude() || swCoord.latitude() > neCoord.latitude()) {
+        qCWarning(TerrainQueryLog) << "UnitTestTerrainQuery::requestCarpetHeights: Internal Error - bad carpet coords";
+        emit qobject_cast<TerrainQueryInterface*>(parent())->carpetHeightsReceived(false, qQNaN(), qQNaN(), carpet);
+        return;
+    }
+
     double min = std::numeric_limits<double>::max();
     double max = std::numeric_limits<double>::min();
-    QList<QList<double>> carpet;
     for (double lat = swCoord.latitude(); lat < neCoord.latitude(); lat++) {
-        QList<double> row = requestPathHeightsSync({lat,swCoord.longitude()}, {lat,neCoord.longitude()}).second;
+        QGeoCoordinate fromCoord(lat, swCoord.longitude());
+        QGeoCoordinate toCoord  (lat, neCoord.longitude());
+
+        QList<double> row = _requestPathHeights(fromCoord, toCoord).rgHeights;
         if (row.size() == 0) {
             emit carpetHeightsReceived(false, qQNaN(), qQNaN(), QList<QList<double>>());
             return;
         }
         for (const auto val : row) {
-            min = std::min(val,min);
-            max = std::max(val,max);
+            min = qMin(val, min);
+            max = qMax(val, max);
         }
-        carpet.push_back(row);
+        carpet.append(row);
     }
     emit qobject_cast<TerrainQueryInterface*>(parent())->carpetHeightsReceived(true, min, max, carpet);
 }
 
-QPair<QList<QGeoCoordinate>, QList<double>> UnitTestTerrainQuery::requestPathHeightsSync(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord) {
-    QList<QGeoCoordinate> coordinates;
-    coordinates.push_back(fromCoord);
-
-    //cast to pixels
-    long x0 = std::floor(fromCoord.longitude()/one_second_deg);
-    long x1 = std::floor(toCoord.longitude()/one_second_deg);
-    long y0 = std::floor(fromCoord.latitude()/one_second_deg);
-    long y1 = std::floor(toCoord.latitude()/one_second_deg);
-
-    //bresenham line algo
-    long dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
-    long dy = abs(y1-y0), sy = y0<y1 ? 1 : -1;
-    long err = (dx>dy ? dx : -dy)/2, e2;
-    while(true) {
-        e2 = err;
-        if (e2 >-dx) { err -= dy; x0 += sx; }
-        if (e2 < dy) { err += dx; y0 += sy; }
-        if ((x0==x1 && y0==y1)) {
-            break;
-        }
-        coordinates.push_back({y0*one_second_deg, x0*one_second_deg});
-    }
-    coordinates.push_back(toCoord);
-    return QPair<QList<QGeoCoordinate>, QList<double>>(coordinates, requestCoordinateHeightsSync(coordinates));
+UnitTestTerrainQuery::PathHeightInfo_t UnitTestTerrainQuery::_requestPathHeights(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord)
+{
+    PathHeightInfo_t   pathHeights;
+
+    pathHeights.rgCoords    = TerrainTileManager::pathQueryToCoords(fromCoord, toCoord, pathHeights.distanceBetween, pathHeights.finalDistanceBetween);
+    pathHeights.rgHeights   = _requestCoordinateHeights(pathHeights.rgCoords);
+
+    return pathHeights;
 }
 
-QList<double>  UnitTestTerrainQuery::requestCoordinateHeightsSync(const QList<QGeoCoordinate>& coordinates) {
+QList<double> UnitTestTerrainQuery::_requestCoordinateHeights(const QList<QGeoCoordinate>& coordinates)
+{
     QList<double> result;
+
     for (const auto& coordinate : coordinates) {
         if (flat10Region.contains(coordinate)) {
-            result.push_back(UnitTestTerrainQuery::Flat10Region::elevationMts);
+            result.append(UnitTestTerrainQuery::Flat10Region::amslElevation);
         } else if (linearSlopeRegion.contains(coordinate)) {
             //cast to one_second_deg grid and round to int to emulate SRTM1 even better
             long x = (coordinate.longitude() - linearSlopeRegion.topLeft().longitude())/one_second_deg;
-            long dx = regionExtentDeg/one_second_deg;
+            long dx = regionSizeDeg/one_second_deg;
             double fraction = 1.0 * x / dx;
-            result.push_back(
-                std::round(
-                    UnitTestTerrainQuery::LinearSlopeRegion::minElevationMts
-                    + (fraction * UnitTestTerrainQuery::LinearSlopeRegion::dElevationMts)
-                )
-            );
+            result.append(std::round(UnitTestTerrainQuery::LinearSlopeRegion::minAMSLElevation + (fraction * UnitTestTerrainQuery::LinearSlopeRegion::totalElevationChange)));
         } else {
             result.clear();
             break;
         }
     }
+
     return result;
 }

src/Terrain/TerrainQuery.h

@@ -120,8 +120,10 @@ public:
     void addPathQuery               (TerrainOfflineAirMapQuery* terrainQueryInterface, const QGeoCoordinate& startPoint, const QGeoCoordinate& endPoint);
     bool getAltitudesForCoordinates (const QList<QGeoCoordinate>& coordinates, QList<double>& altitudes, bool& error);
 
+    static QList<QGeoCoordinate> pathQueryToCoords(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord, double& distanceBetween, double& finalDistanceBetween);
+
 private slots:
-    void _terrainDone       (QByteArray responseBytes, QNetworkReply::NetworkError error);
+    void _terrainDone(QByteArray responseBytes, QNetworkReply::NetworkError error);
 
 private:
     enum class State {
@@ -296,53 +298,63 @@ private:
     TerrainPathQuery                            _pathQuery;
 };
 
-///
-/// @brief The MockTerrainQuery class provides unit test terrain query responses for the disconnected environment.
-/// @details It provides preset, emulated, 1 arc-second (SRMT1) resultion regions that are either
-/// flat, sloped or rugged in a fashion that aids testing terrain-sensitive functionality. All emulated
+/// @brief Provides unit test terrain query responses.
+/// @details It provides preset, emulated, 1 arc-second (SRTM1) resolution regions that are either
+/// flat or sloped in a fashion that aids testing terrain-sensitive functionality. All emulated
 /// regions are positioned around Point Nemo - should real terrain became useful and checked in one day.
-///
 class UnitTestTerrainQuery : public TerrainQueryInterface {
 public:
 
-    static constexpr double regionExtentDeg = 0.1; //every region 0.1deg x 0.1deg across (around 11km north to south)
+    static constexpr double regionSizeDeg   = 0.1;      // all regions are 0.1deg (~11km) square
     static constexpr double one_second_deg  = 1.0/3600;
 
-    /// @brief Point Nemo is a point on Earth furthest from land
+    /// Point Nemo is a point on Earth furthest from land
     static const QGeoCoordinate pointNemo;
 
-    ///
-    /// @brief flat10Region is a region with constant 10m terrain elevation
-    ///
-    struct Flat10Region : public QGeoRectangle {
+    /// Region with constant 10m terrain elevation
+    struct Flat10Region : public QGeoRectangle
+    {
         Flat10Region(const QGeoRectangle& region)
-        :QGeoRectangle(region)
-        {}
+            : QGeoRectangle(region)
+        {
+
+        }
 
-        static const double elevationMts;
+        static const double amslElevation;
     };
     static const Flat10Region flat10Region;
 
-    ///
-    /// @brief linearSlopeRegion is a region with a linear west to east slope raising from -100m to 1000m
-    ///
-    struct LinearSlopeRegion : public QGeoRectangle {
+    /// Region with a linear west to east slope raising at a rate of 100 meters per kilometer (-100m to 1000m)
+    struct LinearSlopeRegion : public QGeoRectangle
+    {
         LinearSlopeRegion(const QGeoRectangle& region)
-        :QGeoRectangle(region)
-        {}
+            : QGeoRectangle(region)
+        {
+
+        }
 
-        static const double minElevationMts;
-        static const double maxElevationMts;
-        static const double dElevationMts;
+        static const double minAMSLElevation;
+        static const double maxAMSLElevation;
+        static const double totalElevationChange;
     };
     static const LinearSlopeRegion linearSlopeRegion;
 
     UnitTestTerrainQuery(TerrainQueryInterface* parent = nullptr);
 
-    void requestCoordinateHeights(const QList<QGeoCoordinate>& coordinates) Q_DECL_OVERRIDE;
-    void requestPathHeights(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord) Q_DECL_OVERRIDE;
-    void requestCarpetHeights(const QGeoCoordinate& swCoord, const QGeoCoordinate& neCoord, bool statsOnly) Q_DECL_OVERRIDE;
-    QList<double> requestCoordinateHeightsSync(const QList<QGeoCoordinate>& coordinates);
-    QPair<QList<QGeoCoordinate>, QList<double>> requestPathHeightsSync(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord);
+    // Overrides from TerrainQueryInterface
+    void requestCoordinateHeights   (const QList<QGeoCoordinate>& coordinates) override;
+    void requestPathHeights         (const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord) override;
+    void requestCarpetHeights       (const QGeoCoordinate& swCoord, const QGeoCoordinate& neCoord, bool statsOnly) override;
+
+private:
+    typedef struct {
+        QList<QGeoCoordinate>   rgCoords;
+        QList<double>           rgHeights;
+        double                  distanceBetween;
+        double                  finalDistanceBetween;
+    } PathHeightInfo_t;
+
+    QList<double> _requestCoordinateHeights(const QList<QGeoCoordinate>& coordinates);
+    PathHeightInfo_t _requestPathHeights(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord);
 };
 

src/TerrainTile.cc

@@ -152,7 +152,7 @@ QGeoCoordinate TerrainTile::centerCoordinate(void) const
     return _southWest.atDistanceAndAzimuth(_southWest.distanceTo(_northEast) / 2.0, _southWest.azimuthTo(_northEast));
 }
 
-QByteArray TerrainTile::serialize(QByteArray input)
+QByteArray TerrainTile::serializeFromAirMapJson(QByteArray input)
 {
     QJsonParseError parseError;
     QJsonDocument document = QJsonDocument::fromJson(input, &parseError);

src/TerrainTile.h

@@ -20,13 +20,6 @@ public:
     ~TerrainTile();
 
     /**
-    * Constructor from json doc with elevation data (either from file or web)
-    *
-    * @param document
-    */
-    TerrainTile(QJsonDocument document);
-
-    /**
     * Constructor from serialized elevation data (either from file or web)
     *
     * @param document
@@ -76,12 +69,7 @@ public:
     */
     QGeoCoordinate centerCoordinate(void) const;
 
-    /**
-    * Serialize data
-    *
-    * @return serialized data
-    */
-    static QByteArray serialize(QByteArray input);
+    static QByteArray serializeFromAirMapJson(QByteArray input);
 
     static constexpr double tileSizeDegrees         = 0.01;         ///< Each terrain tile represents a square area .01 degrees in lat/lon
     static constexpr double tileValueSpacingDegrees = 1.0 / 3600;   ///< 1 Arc-Second spacing of elevation values