min tile area -> percent

src/Wima/Geometry/WimaMeasurementArea.cc

@@ -57,12 +57,10 @@ size_t TileData::size() const {
 const char *WimaMeasurementArea::settingsGroup = "MeasurementArea";
 const char *WimaMeasurementArea::tileHeightName = "TileHeight";
 const char *WimaMeasurementArea::tileWidthName = "TileWidth";
-const char *WimaMeasurementArea::minTileAreaName = "MinTileArea";
+const char *WimaMeasurementArea::minTileAreaName = "MinTileAreaPercent";
 const char *WimaMeasurementArea::showTilesName = "ShowTiles";
 const char *WimaMeasurementArea::WimaMeasurementAreaName = "Measurement Area";
 
-void tileDeleter(QmlObjectListModel *tiles) { tiles->clearAndDeleteContents(); }
-
 WimaMeasurementArea::WimaMeasurementArea(QObject *parent)
     : WimaArea(parent),
       _metaDataMap(FactMetaData::createMapFromJsonFile(
@@ -72,7 +70,8 @@ WimaMeasurementArea::WimaMeasurementArea(QObject *parent)
                                this /* QObject parent */)),
       _tileWidth(SettingsFact(settingsGroup, _metaDataMap[tileWidthName],
                               this /* QObject parent */)),
-      _minTileArea(SettingsFact(settingsGroup, _metaDataMap[minTileAreaName],
+      _minTileAreaPercent(SettingsFact(settingsGroup,
+                                       _metaDataMap[minTileAreaName],
                                        this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                               this /* QObject parent */)),
@@ -90,7 +89,8 @@ WimaMeasurementArea::WimaMeasurementArea(const WimaMeasurementArea &other,
                                this /* QObject parent */)),
       _tileWidth(SettingsFact(settingsGroup, _metaDataMap[tileWidthName],
                               this /* QObject parent */)),
-      _minTileArea(SettingsFact(settingsGroup, _metaDataMap[minTileAreaName],
+      _minTileAreaPercent(SettingsFact(settingsGroup,
+                                       _metaDataMap[minTileAreaName],
                                        this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                               this /* QObject parent */)),
@@ -123,7 +123,7 @@ Fact *WimaMeasurementArea::tileHeight() { return &_tileHeight; }
 
 Fact *WimaMeasurementArea::tileWidth() { return &_tileWidth; }
 
-Fact *WimaMeasurementArea::minTileArea() { return &_minTileArea; }
+Fact *WimaMeasurementArea::minTileArea() { return &_minTileAreaPercent; }
 
 Fact *WimaMeasurementArea::showTiles() { return &_showTiles; }
 
@@ -156,46 +156,56 @@ int WimaMeasurementArea::maxTiles() const { return SNAKE_MAX_TILES; }
 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();
-  json[minTileAreaName] = _minTileArea.rawValue().toDouble();
+    json[minTileAreaName] = _minTileAreaPercent.rawValue().toDouble();
     json[showTilesName] = _showTiles.rawValue().toBool();
     json[areaTypeName] = WimaMeasurementAreaName;
+  } else {
+    qCDebug(WimaMeasurementAreaLog) << "saveToJson(): not ready for saveing.";
+  }
 }
 
 bool WimaMeasurementArea::loadFromJson(const QJsonObject &json,
                                        QString &errorString) {
   if (this->WimaArea::loadFromJson(json, errorString)) {
+    disableUpdates();
     bool retVal = true;
 
-    if (json.contains(tileHeightName) && json[tileHeightName].isDouble()) {
-      _tileHeight.setRawValue(json[tileHeightName].toDouble());
-    } else {
+    if (!json.contains(tileHeightName) || !json[tileHeightName].isDouble()) {
       errorString.append(tr("Could not load tile height!\n"));
       retVal = false;
     }
 
-    if (json.contains(tileWidthName) && json[tileWidthName].isDouble()) {
-      _tileWidth.setRawValue(json[tileWidthName].toDouble());
-    } else {
+    if (!json.contains(tileWidthName) || !json[tileWidthName].isDouble()) {
       errorString.append(tr("Could not load tile width!\n"));
       retVal = false;
     }
 
-    if (json.contains(minTileAreaName) && json[minTileAreaName].isDouble()) {
-      _minTileArea.setRawValue(json[minTileAreaName].toDouble());
-    } else {
+    if (!json.contains(minTileAreaName) || !json[minTileAreaName].isDouble()) {
       errorString.append(tr("Could not load minimal tile area!\n"));
       retVal = false;
     }
 
-    if (json.contains(showTilesName) && json[showTilesName].isBool()) {
-      _showTiles.setRawValue(json[showTilesName].toBool());
-    } else {
+    if (!json.contains(showTilesName) || !json[showTilesName].isBool()) {
       errorString.append(tr("Could not load show tiles !\n"));
       retVal = false;
     }
+
+    if (retVal) {
+      _tileHeight.setRawValue(json[tileHeightName].toDouble());
+      _tileWidth.setRawValue(json[tileWidthName].toDouble());
+      _minTileAreaPercent.setRawValue(json[minTileAreaName].toDouble());
+      _showTiles.setRawValue(json[showTilesName].toBool());
+
+      enableUpdates();
+      doUpdate();
+    } else {
+      enableUpdates();
+    }
+
     return retVal;
   } else {
     return false;
@@ -222,22 +232,24 @@ 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;
-  if (this->_state != STATE::UPDATE &&
-      long(std::ceil(estNumTiles.value())) <= SNAKE_MAX_TILES &&
+    // Check some conditions.
+    if (long(std::ceil(estNumTiles.value())) <= SNAKE_MAX_TILES &&
         this->count() >= 3 && this->isSimplePolygon()) {
-    setState(STATE::UPDATE);
+      setState(STATE::UPDATEING);
+
       auto polygon = this->coordinateList();
       for (auto &v : polygon) {
         v.setAltitude(0);
       }
       const auto minArea =
-        this->_minTileArea.rawValue().toDouble() * si::meter * si::meter;
+          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();
@@ -284,7 +296,7 @@ void WimaMeasurementArea::doUpdate() {
 
       this->_watcher.setFuture(future);
     }
-
+  }
   qCDebug(WimaMeasurementAreaLog)
       << "doUpdate(): execution time: "
       << std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -295,6 +307,7 @@ void WimaMeasurementArea::doUpdate() {
 
 void WimaMeasurementArea::deferUpdate() {
   if (this->_state == STATE::IDLE || this->_state == STATE::DEFERED) {
+    qCDebug(WimaMeasurementAreaLog) << "defereUpdate(): defer update.";
     if (this->_state == STATE::IDLE) {
       this->_progress.clear();
       this->_tileData.clear();
@@ -303,16 +316,16 @@ void WimaMeasurementArea::deferUpdate() {
     }
     this->setState(STATE::DEFERED);
     this->_timer.start(100);
-  } else if (this->_state == STATE::UPDATE) {
-    setState(STATE::RESTART);
+  } else if (this->_state == STATE::UPDATEING) {
+    qCDebug(WimaMeasurementAreaLog) << "defereUpdate(): restart.";
+    setState(STATE::RESTARTING);
   }
 }
 
 void WimaMeasurementArea::storeTiles() {
   auto start = std::chrono::high_resolution_clock::now();
 
-  if (this->_state == STATE::UPDATE) {
-
+  if (this->_state == STATE::UPDATEING) {
     qCDebug(WimaMeasurementAreaLog) << "storeTiles(): update.";
 
     this->_tileData = *this->_watcher.result();
@@ -321,10 +334,11 @@ void WimaMeasurementArea::storeTiles() {
     this->progressChanged();
     emit this->tilesChanged();
     setState(STATE::IDLE);
-  } else if (this->_state == STATE::RESTART) {
+  } else if (this->_state == STATE::RESTARTING) {
     qCDebug(WimaMeasurementAreaLog) << "storeTiles(): restart.";
-
     doUpdate();
+  } else if (this->_state == STATE::STOP) {
+    qCDebug(WimaMeasurementAreaLog) << "storeTiles(): stop.";
   }
   qCDebug(WimaMeasurementAreaLog)
       << "storeTiles() execution time: "
@@ -334,13 +348,24 @@ void WimaMeasurementArea::storeTiles() {
       << " ms";
 }
 
+void WimaMeasurementArea::disableUpdates() {
+  setState(STATE::IDLE);
+  this->_timer.stop();
+}
+
+void WimaMeasurementArea::enableUpdates() {
+  if (this->_state == STATE::STOP) {
+    setState(STATE::IDLE);
+  }
+}
+
 void WimaMeasurementArea::init() {
   this->setObjectName(WimaMeasurementAreaName);
   connect(&this->_tileHeight, &Fact::rawValueChanged, this,
           &WimaMeasurementArea::deferUpdate);
   connect(&this->_tileWidth, &Fact::rawValueChanged, this,
           &WimaMeasurementArea::deferUpdate);
-  connect(&this->_minTileArea, &Fact::rawValueChanged, this,
+  connect(&this->_minTileAreaPercent, &Fact::rawValueChanged, this,
           &WimaMeasurementArea::deferUpdate);
   connect(this, &WimaArea::pathChanged, this,
           &WimaMeasurementArea::deferUpdate);

src/Wima/Geometry/WimaMeasurementArea.h

@@ -27,12 +27,7 @@ public:
 class WimaMeasurementArea : public WimaArea {
   Q_OBJECT
 
-  enum class STATE {
-    IDLE,
-    DEFERED,
-    UPDATE,
-    RESTART,
-  };
+  enum class STATE { IDLE, DEFERED, UPDATEING, RESTARTING, STOP };
 
 public:
   WimaMeasurementArea(QObject *parent = nullptr);
@@ -71,10 +66,6 @@ public:
   void saveToJson(QJsonObject &json);
   bool loadFromJson(const QJsonObject &json, QString &errorString);
 
-  // Friends
-  friend void print(const WimaMeasurementArea &area, QString outputStr);
-  friend void print(const WimaMeasurementArea &area);
-
   // Static Variables
   static const char *settingsGroup;
   static const char *tileHeightName;
@@ -98,6 +89,8 @@ private slots:
   void doUpdate();
   void deferUpdate();
   void storeTiles();
+  void disableUpdates();
+  void enableUpdates();
 
 private:
   // Member Methodes
@@ -109,15 +102,15 @@ private:
 
   SettingsFact _tileHeight;
   SettingsFact _tileWidth;
-  SettingsFact _minTileArea;
+  SettingsFact _minTileAreaPercent; // 0..100
   SettingsFact _showTiles;
 
+  QVector<int> _progress;
+
   // Tile stuff.
   mutable QTimer _timer;
   using DataPtr = std::shared_ptr<TileData>;
+  mutable STATE _state;
   mutable TileData _tileData;
   mutable QFutureWatcher<DataPtr> _watcher;
-  mutable STATE _state;
-
-  QVector<int> _progress;
 };

src/Wima/Geometry/json/WimaMeasurementArea.SettingsGroup.json

@@ -18,31 +18,14 @@
     "defaultValue":     5
 },
 {
-    "name":             "MinTileArea",
-    "shortDescription": "The minimal allowed area of a tile",
+    "name":             "MinTileAreaPercent",
+    "shortDescription": "The minimal allowed area in percent (of width*height).",
     "type":             "double",
-    "units":            "m^2",
+    "units":            "%",
     "min":              0,
+    "max":              100,
     "decimalPlaces":    2,
-    "defaultValue":     5
-},
-{
-    "name":             "TransectDistance",
-    "shortDescription": "The transect distance",
-    "type":             "double",
-    "units":            "m",
-    "min":              0.3,
-    "decimalPlaces":    2,
-    "defaultValue":     2
-},
-{
-    "name":             "MinTransectLength",
-    "shortDescription": "The minimal transect length",
-    "type":             "double",
-    "units":            "m",
-    "min":              0,
-    "decimalPlaces":    2,
-    "defaultValue":     1
+    "defaultValue":     20
 },
 {
     "name":             "ShowTiles",