merged with remote dev1

src/Wima/Geometry/WimaMeasurementArea.cc

@@ -72,7 +72,7 @@ WimaMeasurementArea::WimaMeasurementArea(QObject *parent)
                               this /* QObject parent */)),
       _minTileAreaPercent(SettingsFact(settingsGroup,
                                        _metaDataMap[minTileAreaName],
-                                       this /* QObject parent */)),
+                                      this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                               this /* QObject parent */)),
       _state(STATE::IDLE) {
@@ -91,7 +91,7 @@ WimaMeasurementArea::WimaMeasurementArea(const WimaMeasurementArea &other,
                               this /* QObject parent */)),
       _minTileAreaPercent(SettingsFact(settingsGroup,
                                        _metaDataMap[minTileAreaName],
-                                       this /* QObject parent */)),
+                                      this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                               this /* QObject parent */)),
       _state(STATE::IDLE) {
@@ -157,12 +157,12 @@ bool WimaMeasurementArea::ready() const { return this->_state == STATE::IDLE; }
 
 void WimaMeasurementArea::saveToJson(QJsonObject &json) {
   if (ready()) {
-    this->WimaArea::saveToJson(json);
-    json[tileHeightName] = _tileHeight.rawValue().toDouble();
-    json[tileWidthName] = _tileWidth.rawValue().toDouble();
+  this->WimaArea::saveToJson(json);
+  json[tileHeightName] = _tileHeight.rawValue().toDouble();
+  json[tileWidthName] = _tileWidth.rawValue().toDouble();
     json[minTileAreaName] = _minTileAreaPercent.rawValue().toDouble();
-    json[showTilesName] = _showTiles.rawValue().toBool();
-    json[areaTypeName] = WimaMeasurementAreaName;
+  json[showTilesName] = _showTiles.rawValue().toBool();
+  json[areaTypeName] = WimaMeasurementAreaName;
   } else {
     qCDebug(WimaMeasurementAreaLog) << "saveToJson(): not ready for saveing.";
   }
@@ -231,70 +231,70 @@ void WimaMeasurementArea::doUpdate() {
   using namespace boost::units;
 
   auto start = std::chrono::high_resolution_clock::now();
-  // Check state.
+
   if (this->_state != STATE::UPDATEING && this->_state != STATE::STOP) {
-    const auto height = this->_tileHeight.rawValue().toDouble() * si::meter;
-    const auto width = this->_tileWidth.rawValue().toDouble() * si::meter;
-    const auto tileArea = width * height;
-    const auto totalArea = this->area() * si::meter * si::meter;
-    const auto estNumTiles = totalArea / tileArea;
+  const auto height = this->_tileHeight.rawValue().toDouble() * si::meter;
+  const auto width = this->_tileWidth.rawValue().toDouble() * si::meter;
+  const auto tileArea = width * height;
+  const auto totalArea = this->area() * si::meter * si::meter;
+  const auto estNumTiles = totalArea / tileArea;
     // Check some conditions.
     if (long(std::ceil(estNumTiles.value())) <= SNAKE_MAX_TILES &&
-        this->count() >= 3 && this->isSimplePolygon()) {
+      this->count() >= 3 && this->isSimplePolygon()) {
       setState(STATE::UPDATEING);
 
-      auto polygon = this->coordinateList();
-      for (auto &v : polygon) {
-        v.setAltitude(0);
-      }
-      const auto minArea =
+    auto polygon = this->coordinateList();
+    for (auto &v : polygon) {
+      v.setAltitude(0);
+    }
+    const auto minArea =
           this->_minTileAreaPercent.rawValue().toDouble() / 100 * tileArea;
-      auto *th = this->thread();
-      auto future = QtConcurrent::run([polygon, th, height, width, minArea] {
-        auto start = std::chrono::high_resolution_clock::now();
-
-        DataPtr pData(new TileData());
-        // Convert to ENU system.
-        QGeoCoordinate origin = polygon.first();
-        FPolygon polygonENU;
-        areaToEnu(origin, polygon, polygonENU);
-        std::vector<FPolygon> tilesENU;
-        BoundingBox bbox;
-        std::string errorString;
-        // Generate tiles.
-        if (snake::tiles(polygonENU, height, width, minArea, tilesENU, bbox,
-                         errorString)) {
-          // Convert to geo system.
-          for (const auto &t : tilesENU) {
-            auto geoTile = new SnakeTile(pData.get());
-            for (const auto &v : t.outer()) {
-              QGeoCoordinate geoVertex;
-              fromENU(origin, v, geoVertex);
-              geoTile->push_back(geoVertex);
-            }
-            pData->tiles.append(geoTile);
-            // Calculate center.
-            snake::FPoint center;
-            snake::polygonCenter(t, center);
-            QGeoCoordinate geoCenter;
-            fromENU(origin, center, geoCenter);
-            pData->tileCenterPoints.append(QVariant::fromValue(geoCenter));
+    auto *th = this->thread();
+    auto future = QtConcurrent::run([polygon, th, height, width, minArea] {
+      auto start = std::chrono::high_resolution_clock::now();
+
+      DataPtr pData(new TileData());
+      // Convert to ENU system.
+      QGeoCoordinate origin = polygon.first();
+      FPolygon polygonENU;
+      areaToEnu(origin, polygon, polygonENU);
+      std::vector<FPolygon> tilesENU;
+      BoundingBox bbox;
+      std::string errorString;
+      // Generate tiles.
+      if (snake::tiles(polygonENU, height, width, minArea, tilesENU, bbox,
+                       errorString)) {
+        // Convert to geo system.
+        for (const auto &t : tilesENU) {
+          auto geoTile = new SnakeTile(pData.get());
+          for (const auto &v : t.outer()) {
+            QGeoCoordinate geoVertex;
+            fromENU(origin, v, geoVertex);
+            geoTile->push_back(geoVertex);
           }
+          pData->tiles.append(geoTile);
+          // Calculate center.
+          snake::FPoint center;
+          snake::polygonCenter(t, center);
+          QGeoCoordinate geoCenter;
+          fromENU(origin, center, geoCenter);
+          pData->tileCenterPoints.append(QVariant::fromValue(geoCenter));
         }
-        pData->moveToThread(th);
+      }
+      pData->moveToThread(th);
 
-        qCDebug(WimaMeasurementAreaLog)
-            << "doUpdate(): update time: "
-            << std::chrono::duration_cast<std::chrono::milliseconds>(
-                   std::chrono::high_resolution_clock::now() - start)
-                   .count()
-            << " ms";
+      qCDebug(WimaMeasurementAreaLog)
+          << "doUpdate(): update time: "
+          << std::chrono::duration_cast<std::chrono::milliseconds>(
+                 std::chrono::high_resolution_clock::now() - start)
+                 .count()
+          << " ms";
 
-        return pData;
-      }); // QtConcurrent::run()
+      return pData;
+    }); // QtConcurrent::run()
 
-      this->_watcher.setFuture(future);
-    }
+    this->_watcher.setFuture(future);
+  }
   }
   qCDebug(WimaMeasurementAreaLog)
       << "doUpdate(): execution time: "

src/Wima/Geometry/WimaMeasurementArea.h

@@ -106,7 +106,7 @@ private:
   SettingsFact _showTiles;
 
   QVector<int> _progress;
-
+  // Tile stuff.
   // Tile stuff.
   mutable QTimer _timer;
   using DataPtr = std::shared_ptr<TileData>;

src/Wima/Geometry/WimaMeasurementArea.h.orig

+#pragma once
+
+#include <QFutureWatcher>
+#include <QObject>
+#include <QTimer>
+
+#include "WimaArea.h"
+
+#include "SettingsFact.h"
+
+class TileData : public QObject {
+public:
+  QmlObjectListModel tiles;
+  QVariantList tileCenterPoints;
+
+  TileData();
+  ~TileData();
+
+  TileData &operator=(const TileData &other);
+  bool operator==(const TileData &other) const;
+  bool operator!=(const TileData &other) const;
+
+  void clear();
+  std::size_t size() const;
+};
+
+class WimaMeasurementArea : public WimaArea {
+  Q_OBJECT
+
+  enum class STATE { IDLE, DEFERED, UPDATEING, RESTARTING, STOP };
+
+public:
+  WimaMeasurementArea(QObject *parent = nullptr);
+  WimaMeasurementArea(const WimaMeasurementArea &other,
+                      QObject *parent = nullptr);
+  WimaMeasurementArea &operator=(const WimaMeasurementArea &other);
+  ~WimaMeasurementArea();
+
+  Q_PROPERTY(Fact *tileHeight READ tileHeight CONSTANT)
+  Q_PROPERTY(Fact *tileWidth READ tileWidth CONSTANT)
+  Q_PROPERTY(Fact *minTileArea READ minTileArea CONSTANT)
+  Q_PROPERTY(Fact *showTiles READ showTiles CONSTANT)
+  Q_PROPERTY(QmlObjectListModel *tiles READ tiles NOTIFY tilesChanged)
+  Q_PROPERTY(int maxTiles READ maxTiles NOTIFY maxTilesChanged)
+  Q_PROPERTY(QVector<int> progress READ progressQml NOTIFY progressChanged)
+
+  // Overrides from WimaPolygon
+  QString mapVisualQML(void) const;
+  QString editorQML(void) const;
+
+  // Property getters.
+  Fact *tileHeight();
+  Fact *tileWidth();
+  Fact *minTileArea();
+  Fact *showTiles();
+  QmlObjectListModel *tiles();
+  const QVector<int> &progress() const;
+  QVector<int> progressQml() const;
+  const QmlObjectListModel *tiles() const;
+  const QVariantList &tileCenterPoints() const; // List of QGeoCoordinate
+  const TileData &tileData() const;
+  int maxTiles() const;
+  bool ready() const;
+
+  // Member Methodes
+  void saveToJson(QJsonObject &json);
+  bool loadFromJson(const QJsonObject &json, QString &errorString);
+
+  // Static Variables
+  static const char *settingsGroup;
+  static const char *tileHeightName;
+  static const char *tileWidthName;
+  static const char *minTileAreaName;
+  static const char *showTilesName;
+  static const char *WimaMeasurementAreaName;
+
+signals:
+  void tilesChanged();
+  void maxTilesChanged();
+  void progressChanged();
+  void progressAccepted();
+  void progressNotAccepted();
+  void readyChanged();
+
+public slots:
+  bool setProgress(const QVector<int> &p);
+
+private slots:
+  void doUpdate();
+  void deferUpdate();
+  void storeTiles();
+  void disableUpdate();
+  void enableUpdate();
+
+private:
+  // Member Methodes
+  void init();
+  void setState(STATE s);
+
+  // Members
+  QMap<QString, FactMetaData *> _metaDataMap;
+
+  SettingsFact _tileHeight;
+  SettingsFact _tileWidth;
+<<<<<<< HEAD
+  SettingsFact _minTileAreaPercent; // 0..100
+=======
+  SettingsFact _minTileArea;
+>>>>>>> 118a8e164c4fec6026709eb5bee77aa75fd3de95
+  SettingsFact _showTiles;
+
+  QVector<int> _progress;
+
+  // Tile stuff.
+  mutable QTimer _timer;
+  using DataPtr = std::shared_ptr<TileData>;
+<<<<<<< HEAD
+  mutable STATE _state;
+  mutable TileData _tileData;
+  mutable QFutureWatcher<DataPtr> _watcher;
+=======
+  mutable TileData _tileData;
+  mutable QFutureWatcher<DataPtr> _watcher;
+  mutable STATE _state;
+
+  QVector<int> _progress;
+>>>>>>> 118a8e164c4fec6026709eb5bee77aa75fd3de95
+};

src/Wima/Snake/NemoInterface.cpp

@@ -163,28 +163,28 @@ void NemoInterface::Impl::setTileData(const TileData &tileData) {
     if (tile != nullptr) {
       if (tile->coordinateList().size() > 0) {
         if (tile->coordinateList().first().isValid()) {
-          this->ENUOrigin = tile->coordinateList().first();
-          const auto &origin = this->ENUOrigin;
-          this->tilesENU.polygons().clear();
-          for (int i = 0; i < tileData.tiles.count(); ++i) {
-            obj = tileData.tiles.get(i);
-            tile = qobject_cast<const SnakeTile *>(obj);
-            if (tile != nullptr) {
-              SnakeTileLocal tileENU;
-              snake::areaToEnu(origin, tile->coordinateList(), tileENU.path());
-              this->tilesENU.polygons().push_back(std::move(tileENU));
-            } else {
+        this->ENUOrigin = tile->coordinateList().first();
+        const auto &origin = this->ENUOrigin;
+        this->tilesENU.polygons().clear();
+        for (int i = 0; i < tileData.tiles.count(); ++i) {
+          obj = tileData.tiles.get(i);
+          tile = qobject_cast<const SnakeTile *>(obj);
+          if (tile != nullptr) {
+            SnakeTileLocal tileENU;
+            snake::areaToEnu(origin, tile->coordinateList(), tileENU.path());
+            this->tilesENU.polygons().push_back(std::move(tileENU));
+          } else {
               qCDebug(NemoInterfaceLog) << "Impl::setTileData(): nullptr.";
-              break;
-            }
+            break;
           }
-        } else {
-          qCDebug(NemoInterfaceLog) << "Impl::setTileData(): Origin invalid.";
         }
       } else {
-        qCDebug(NemoInterfaceLog) << "Impl::setTileData(): tile empty.";
+          qCDebug(NemoInterfaceLog) << "Impl::setTileData(): Origin invalid.";
       }
+      } else {
+        qCDebug(NemoInterfaceLog) << "Impl::setTileData(): tile empty.";
     }
+  }
   } else {
     this->tileData.clear();
 
@@ -307,7 +307,7 @@ void NemoInterface::Impl::doTopicServiceSetup() {
         if (geographic_msgs::geo_point::toJson(origin, jOrigin,
                                                pDoc->GetAllocator())) {
           lk.unlock();
-          pDoc->AddMember("origin", jOrigin, pDoc->GetAllocator());
+        pDoc->AddMember("origin", jOrigin, pDoc->GetAllocator());
         } else {
           lk.unlock();
           qCWarning(NemoInterfaceLog)
@@ -330,7 +330,7 @@ void NemoInterface::Impl::doTopicServiceSetup() {
         if (jsk_recognition_msgs::polygon_array::toJson(
                 this->tilesENU, jSnakeTiles, pDoc->GetAllocator())) {
           lk.unlock();
-          pDoc->AddMember("tiles", jSnakeTiles, pDoc->GetAllocator());
+        pDoc->AddMember("tiles", jSnakeTiles, pDoc->GetAllocator());
         } else {
           lk.unlock();
           qCWarning(NemoInterfaceLog)
@@ -350,7 +350,7 @@ void NemoInterface::Impl::loop() {
     } else if (this->pRosBridge->isRunning() && this->pRosBridge->connected() &&
                !this->topicServiceSetupDone) {
       this->doTopicServiceSetup();
-      this->topicServiceSetupDone = true;
+        this->topicServiceSetupDone = true;
 
       this->setStatus(STATUS::WEBSOCKET_DETECTED);
     } else if (this->pRosBridge->isRunning() &&
@@ -395,7 +395,7 @@ void NemoInterface::Impl::publishTilesENU() {
       std::make_unique<rapidjson::Document>(rapidjson::kObjectType));
   if (jsk_recognition_msgs::polygon_array::toJson(
           this->tilesENU, *jSnakeTiles, jSnakeTiles->GetAllocator())) {
-    this->pRosBridge->publish(std::move(jSnakeTiles), "/snake/tiles");
+  this->pRosBridge->publish(std::move(jSnakeTiles), "/snake/tiles");
   } else {
     qCWarning(NemoInterfaceLog)
         << "Impl::publishTilesENU: could not create json document.";
@@ -408,7 +408,7 @@ void NemoInterface::Impl::publishENUOrigin() {
       std::make_unique<rapidjson::Document>(rapidjson::kObjectType));
   if (geographic_msgs::geo_point::toJson(this->ENUOrigin, *jOrigin,
                                          jOrigin->GetAllocator())) {
-    this->pRosBridge->publish(std::move(jOrigin), "/snake/origin");
+  this->pRosBridge->publish(std::move(jOrigin), "/snake/origin");
   } else {
     qCWarning(NemoInterfaceLog)
         << "Impl::publishENUOrigin: could not create json document.";

src/Wima/WimaPlaner.cc

@@ -246,7 +246,7 @@ void WimaPlaner::removeAll() {
     removeArea(0);
     changesApplied = true;
   }
-  // Reset Items.
+
   _measurementArea = WimaMeasurementArea();
   _joinedArea = WimaJoinedArea();
   _serviceArea = WimaServiceArea();