From d2e5cfdb1a03595e98048b89f61d931826602f40 Mon Sep 17 00:00:00 2001 From: Don Gagne Date: Thu, 17 Dec 2020 10:21:53 -0800 Subject: [PATCH] Terrain unit test back on (#9257) * Cleanup for better readability * Turn follow terrain unit test back one --- src/MissionManager/TransectStyleComplexItemTest.cc | 52 ++++---- src/MissionManager/TransectStyleComplexItemTest.h | 8 +- src/QtLocationPlugin/QGCMapTileSet.cpp | 2 +- src/QtLocationPlugin/QGeoMapReplyQGC.cpp | 2 +- src/Terrain/TerrainQuery.cc | 143 ++++++++++----------- src/Terrain/TerrainQuery.h | 70 +++++----- src/TerrainTile.cc | 2 +- src/TerrainTile.h | 14 +- 8 files changed, 147 insertions(+), 146 deletions(-) diff --git a/src/MissionManager/TransectStyleComplexItemTest.cc b/src/MissionManager/TransectStyleComplexItemTest.cc index 4ea0b32..f3d0604 100644 --- a/src/MissionManager/TransectStyleComplexItemTest.cc +++ b/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 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 rgItems; + _transectStyleItem->appendMissionItems(rgItems, this); + + QList 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{ - {surveyAreaPolygon()->vertexCoordinate(0), CoordTypeSurveyEntry}, - {surveyAreaPolygon()->vertexCoordinate(2), CoordTypeSurveyExit}} - ); } void TestTransectStyleItem::_rebuildTransectsPhase1(void) { rebuildTransectsPhase1Called = true; + + _transects.clear(); + if (_surveyAreaPolygon.count() < 3) { + return; + } + + _transects.append(QList{ + {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); diff --git a/src/MissionManager/TransectStyleComplexItemTest.h b/src/MissionManager/TransectStyleComplexItemTest.h index 32164a6..2b4cd4b 100644 --- a/src/MissionManager/TransectStyleComplexItemTest.h +++ b/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> transects() const { - return _transects; - } private slots: // Overrides from TransectStyleComplexItem diff --git a/src/QtLocationPlugin/QGCMapTileSet.cpp b/src/QtLocationPlugin/QGCMapTileSet.cpp index 878381f..a5b7335 100644 --- a/src/QtLocationPlugin/QGCMapTileSet.cpp +++ b/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()) { diff --git a/src/QtLocationPlugin/QGeoMapReplyQGC.cpp b/src/QtLocationPlugin/QGeoMapReplyQGC.cpp index 7c8040e..36c148c 100644 --- a/src/QtLocationPlugin/QGeoMapReplyQGC.cpp +++ b/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( diff --git a/src/Terrain/TerrainQuery.cc b/src/Terrain/TerrainQuery.cc index 5c3d80a..50cb412 100644 --- a/src/Terrain/TerrainQuery.cc +++ b/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 TerrainTileManager::pathQueryToCoords(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord, double& distanceBetween, double& finalDistanceBetween) { - // Convert to individual coordinate queries QList 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 coordinates; + double distanceBetween; + double finalDistanceBetween; + + coordinates = pathQueryToCoords(startPoint, endPoint, distanceBetween, finalDistanceBetween); bool error; QList 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& coordinates) { - QList result = requestCoordinateHeightsSync(coordinates); + QList result = _requestCoordinateHeights(coordinates); emit qobject_cast(parent())->coordinateHeightsReceived(result.size() == coordinates.size(), result); } void UnitTestTerrainQuery::requestPathHeights(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord) { - QPair, QList> result = requestPathHeightsSync(fromCoord, toCoord); + auto pathHeightInfo = _requestPathHeights(fromCoord, toCoord); emit qobject_cast(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> carpet; + + if (swCoord.longitude() > neCoord.longitude() || swCoord.latitude() > neCoord.latitude()) { + qCWarning(TerrainQueryLog) << "UnitTestTerrainQuery::requestCarpetHeights: Internal Error - bad carpet coords"; + emit qobject_cast(parent())->carpetHeightsReceived(false, qQNaN(), qQNaN(), carpet); + return; + } + double min = std::numeric_limits::max(); double max = std::numeric_limits::min(); - QList> carpet; for (double lat = swCoord.latitude(); lat < neCoord.latitude(); lat++) { - QList row = requestPathHeightsSync({lat,swCoord.longitude()}, {lat,neCoord.longitude()}).second; + QGeoCoordinate fromCoord(lat, swCoord.longitude()); + QGeoCoordinate toCoord (lat, neCoord.longitude()); + + QList row = _requestPathHeights(fromCoord, toCoord).rgHeights; if (row.size() == 0) { emit carpetHeightsReceived(false, qQNaN(), qQNaN(), QList>()); 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(parent())->carpetHeightsReceived(true, min, max, carpet); } -QPair, QList> UnitTestTerrainQuery::requestPathHeightsSync(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord) { - QList 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 = x0dy ? 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>(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 UnitTestTerrainQuery::requestCoordinateHeightsSync(const QList& coordinates) { +QList UnitTestTerrainQuery::_requestCoordinateHeights(const QList& coordinates) +{ QList 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; } diff --git a/src/Terrain/TerrainQuery.h b/src/Terrain/TerrainQuery.h index c9da0af..d7c58f1 100644 --- a/src/Terrain/TerrainQuery.h +++ b/src/Terrain/TerrainQuery.h @@ -120,8 +120,10 @@ public: void addPathQuery (TerrainOfflineAirMapQuery* terrainQueryInterface, const QGeoCoordinate& startPoint, const QGeoCoordinate& endPoint); bool getAltitudesForCoordinates (const QList& coordinates, QList& altitudes, bool& error); + static QList 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& 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 requestCoordinateHeightsSync(const QList& coordinates); - QPair, QList> requestPathHeightsSync(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord); + // Overrides from TerrainQueryInterface + void requestCoordinateHeights (const QList& 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 rgCoords; + QList rgHeights; + double distanceBetween; + double finalDistanceBetween; + } PathHeightInfo_t; + + QList _requestCoordinateHeights(const QList& coordinates); + PathHeightInfo_t _requestPathHeights(const QGeoCoordinate& fromCoord, const QGeoCoordinate& toCoord); }; diff --git a/src/TerrainTile.cc b/src/TerrainTile.cc index 0b1521c..bc2503c 100644 --- a/src/TerrainTile.cc +++ b/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); diff --git a/src/TerrainTile.h b/src/TerrainTile.h index 0bfe8c9..bd1417d 100644 --- a/src/TerrainTile.h +++ b/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