loading almost finished

src/MeasurementComplexItem/AreaData.cc

@@ -13,14 +13,13 @@ QGC_LOGGING_CATEGORY(AreaDataLog, "AreaDataLog")
 
 const char *originKey = "Origin";
 const char *areaListKey = "AreaList";
-const char *initializedKey = "Initialized";
 
 AreaData::AreaData(QObject *parent) : QObject(parent) {}
 
 AreaData::~AreaData() {}
 
 AreaData::AreaData(const AreaData &other, QObject *parent)
-    : QObject(parent), _initialized(false), _showErrorMessages(true) {
+    : QObject(parent), _showErrorMessages(true) {
   *this = other;
 }
 
@@ -35,7 +34,6 @@ AreaData &AreaData::operator=(const AreaData &other) {
   }
 
   _origin = other._origin;
-  _initialized = other._initialized;
 
   return *this;
 }
@@ -130,11 +128,10 @@ bool AreaData::isCorrect() {
   //  qDebug() << ss.str().c_str();
   if (!bg::covered_by(measurementAreaENU, safeAreaENU)) {
     _processError(tr("Measurement Area not inside Safe Area. Please adjust "
-                     "the Measurement Area."));
+                     "the Measurement Area.\n"));
     return false;
   }
 
-  _initialized = true;
   return true;
 }
 
@@ -196,7 +193,6 @@ bool AreaData::initialize(const QGeoCoordinate &bottomLeft,
         safeArea->vertexCoordinate(0).longitude() * 0.5 +
             measurementArea->vertexCoordinate(0).longitude() * 0.5));
 
-    _initialized = true;
     return true;
   } else {
     qCWarning(AreaDataLog)
@@ -206,7 +202,12 @@ bool AreaData::initialize(const QGeoCoordinate &bottomLeft,
   }
 }
 
-bool AreaData::initialized() { return _initialized; }
+bool AreaData::initialized() {
+  auto measurementArea = getGeoArea<MeasurementArea *>(_areaList);
+  auto safeArea = getGeoArea<SafeArea *>(_areaList);
+  return measurementArea != nullptr && safeArea != nullptr &&
+         measurementArea->count() >= 3 && safeArea->count() >= 3;
+}
 
 void AreaData::intersection() {
   if (initialized() && _areasCorrect()) {
@@ -261,6 +262,12 @@ void AreaData::intersection() {
   }
 }
 
+MeasurementArea *AreaData::measurementArea() {
+  return getGeoArea<MeasurementArea *>(_areaList);
+}
+
+SafeArea *AreaData::safeArea() { return getGeoArea<SafeArea *>(_areaList); }
+
 bool AreaData::operator==(const AreaData &other) const {
   if (_areaList.count() == other._areaList.count()) {
     for (int i = 0; i < _areaList.count(); ++i) {
@@ -280,43 +287,29 @@ bool AreaData::operator!=(const AreaData &other) const {
 bool AreaData::load(const QJsonObject &obj, QString &errorString) {
   bool returnValue = true;
 
-  // load initialized.
-  {
-    QString e;
-    QList<JsonHelper::KeyValidateInfo> keyInfo = {
-        {initializedKey, QJsonValue::Bool, true},
-    };
-    if (JsonHelper::validateKeys(obj, keyInfo, e)) {
-      _initialized = obj[initializedKey].toBool();
-    } else {
-      returnValue = false;
-      errorString.append(e);
-      errorString.append("\n");
-    }
-  }
-
   // load areaList.
-  {
-    QString e;
-    QList<JsonHelper::KeyValidateInfo> keyInfo = {
-        {areaListKey, QJsonValue::Array, true},
-    };
-    if (JsonHelper::validateKeys(obj, keyInfo, e)) {
+  if (obj.contains(areaListKey) && obj[areaListKey].isArray()) {
+
     this->clear();
+
     // iterate over json array
     for (const auto valueRef : obj[areaListKey].toArray()) {
       const auto jsonArea = valueRef.toObject();
+
       // check if area type key is present
-        QList<JsonHelper::KeyValidateInfo> areaInfo = {
-            {GeoArea::areaTypeKey, QJsonValue::String, true},
-        };
-        if (!JsonHelper::validateKeys(jsonArea, areaInfo, e)) {
+      if (jsonArea.contains(GeoArea::areaTypeKey) &&
+          jsonArea[GeoArea::areaTypeKey].isString()) {
+
         // load MeasurementArea
         if (jsonArea[GeoArea::areaTypeKey].toString() ==
             MeasurementArea::name) {
+
           auto area = getGeoArea<MeasurementArea *>(_areaList);
+
           if (area == nullptr) {
+
             auto area = new MeasurementArea(this);
+            QString e;
             if (area->loadFromJson(jsonArea, e)) {
               this->insert(area);
             } else {
@@ -332,11 +325,13 @@ bool AreaData::load(const QJsonObject &obj, QString &errorString) {
           }
         }
         // load SafeArea
-          else if (jsonArea[GeoArea::areaTypeKey].toString() ==
-                   SafeArea::name) {
+        else if (jsonArea[GeoArea::areaTypeKey].toString() == SafeArea::name) {
+
           auto area = getGeoArea<SafeArea *>(_areaList);
           if (area == nullptr) {
+
             auto area = new SafeArea(this);
+            QString e;
             if (area->loadFromJson(jsonArea, e)) {
               this->insert(area);
             } else {
@@ -357,41 +352,27 @@ bool AreaData::load(const QJsonObject &obj, QString &errorString) {
           errorString.append(tr("Unknown area type: ") +
                              jsonArea[GeoArea::areaTypeKey].toString());
         }
-        }
+      } else {
         // GeoArea::areaTypeKey missing
-        else {
         returnValue = false;
-          errorString.append(e);
-          errorString.append("\n");
-        }
+        errorString.append(
+            "Area type key missing, not able to determine area type.\n");
       }
     }
+  } else {
     // AreaList missing
-    else {
     returnValue = false;
-      errorString.append(e);
-      errorString.append("\n");
-    }
+    errorString.append("Not able to load areas.\n");
   }
 
   // load origin
-  {
-    QString e;
-    QList<JsonHelper::KeyValidateInfo> keyInfo = {
-        {originKey, QJsonValue::Object, true},
-    };
-    if (JsonHelper::validateKeys(obj, keyInfo, e)) {
+  if (obj.contains(originKey) && obj[originKey].isObject()) {
     QGeoCoordinate origin;
+    QString e;
     if (JsonHelper::loadGeoCoordinate(obj[originKey], false, origin, e)) {
       _origin = origin;
     }
   }
-  }
-
-  // check if this is correct.
-  if (!this->isCorrect()) {
-    returnValue = false;
-  }
 
   return returnValue;
 }
@@ -402,7 +383,6 @@ bool AreaData::save(QJsonObject &obj) {
   QJsonValue jsonOrigin;
   JsonHelper::saveGeoCoordinate(_origin, false, jsonOrigin);
   temp[originKey] = jsonOrigin;
-  temp[initializedKey] = _initialized;
 
   QJsonArray jsonAreaList;
   for (int i = 0; i < _areaList.count(); ++i) {

src/MeasurementComplexItem/AreaData.h

@@ -71,6 +71,9 @@ public:
   Q_INVOKABLE bool initialized();
   Q_INVOKABLE void intersection();
 
+  Q_INVOKABLE MeasurementArea *measurementArea();
+  Q_INVOKABLE SafeArea *safeArea();
+
   bool operator==(const AreaData &other) const;
   bool operator!=(const AreaData &other) const;
 
@@ -98,7 +101,6 @@ private:
 
   QGeoCoordinate _origin;
   QmlObjectListModel _areaList;
-  bool _initialized;
   QString _errorString;
   bool _showErrorMessages;
 };

src/MeasurementComplexItem/CircularGenerator.cpp

@@ -21,8 +21,6 @@ template <> inline auto get<1>(const IntPoint &p) { return p.Y; }
 namespace routing {
 
 namespace {
-const QString generatorType = "CircularGenerator";
-
 GeneratorBase *creator(QObject *parent) {
   return new CircularGenerator(parent);
 }
@@ -33,8 +31,6 @@ const char *minLengthKey = "MinLength";
 const char *referenceKey = "ReferencePoint";
 } // namespace
 
-REGISTER_GENERATOR(generatorType, creator)
-
 bool circularTransects(const snake::FPoint &reference,
                        const snake::FPolygon &polygon,
                        const std::vector<snake::FPolygon> &tiles,
@@ -42,9 +38,20 @@ bool circularTransects(const snake::FPoint &reference,
                        snake::Length minLength, snake::Transects &transects);
 
 const char *CircularGenerator::settingsGroup = "CircularGenerator";
+const char *CircularGenerator::typeString = "CircularGenerator";
+
+REGISTER_GENERATOR(CircularGenerator::typeString, creator)
 
 CircularGenerator::CircularGenerator(QObject *parent)
-    : CircularGenerator(nullptr, parent) {}
+    : GeneratorBase(parent),
+      _metaDataMap(FactMetaData::createMapFromJsonFile(
+          QStringLiteral(":/json/CircularGenerator.SettingsGroup.json"), this)),
+      _distance(settingsGroup, _metaDataMap[distanceKey]),
+      _deltaAlpha(settingsGroup, _metaDataMap[deltaAlphaKey]),
+      _minLength(settingsGroup, _metaDataMap[minLengthKey]),
+      _measurementArea(nullptr) {
+  init();
+}
 
 CircularGenerator::CircularGenerator(GeneratorBase::Data d, QObject *parent)
     : GeneratorBase(d, parent),
@@ -54,28 +61,20 @@ CircularGenerator::CircularGenerator(GeneratorBase::Data d, QObject *parent)
       _deltaAlpha(settingsGroup, _metaDataMap[deltaAlphaKey]),
       _minLength(settingsGroup, _metaDataMap[minLengthKey]),
       _measurementArea(nullptr) {
-  connect(this->distance(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->deltaAlpha(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->minLength(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this, &CircularGenerator::referenceChanged, this,
-          &GeneratorBase::generatorChanged);
-  setName(tr("Circular Generator"));
+  init();
 }
 
-QString CircularGenerator::editorQml() {
+QString CircularGenerator::editorQml() const {
   return QStringLiteral("CircularGeneratorEditor.qml");
 }
 
-QString CircularGenerator::mapVisualQml() {
+QString CircularGenerator::mapVisualQml() const {
   return QStringLiteral("CircularGeneratorMapVisual.qml");
 }
 
-QString CircularGenerator::abbreviation() { return tr("C. Gen."); }
+QString CircularGenerator::abbreviation() const { return tr("C. Gen."); }
 
-QString CircularGenerator::type() { return generatorType; }
+QString CircularGenerator::type() const { return typeString; }
 
 bool CircularGenerator::get(Generator &generator) {
   if (this->_d) {
@@ -327,6 +326,7 @@ void CircularGenerator::resetReferenceIfInvalid() {
 }
 
 void CircularGenerator::resetReference() {
+  if (this->_d != nullptr) {
     auto measurementArea =
         getGeoArea<const MeasurementArea *>(*this->_d->areaList());
 
@@ -341,6 +341,7 @@ void CircularGenerator::resetReference() {
       qCDebug(CircularGeneratorLog)
           << "resetReference(): measurement area == nullptr";
     }
+  }
 }
 
 Fact *CircularGenerator::distance() { return &_distance; }
@@ -350,8 +351,34 @@ Fact *CircularGenerator::deltaAlpha() { return &_deltaAlpha; }
 Fact *CircularGenerator::minLength() { return &_minLength; }
 
 void CircularGenerator::onAreaListChanged() {
-  auto *measurementArea = getGeoArea<MeasurementArea *>(*this->_d->areaList());
+  if (this->_d != nullptr) {
+    auto *measurementArea =
+        getGeoArea<MeasurementArea *>(*this->_d->areaList());
     setMeasurementArea(measurementArea);
+  }
+}
+
+void CircularGenerator::onDataChanged() {
+  if (this->_d != nullptr) {
+    connect(this->_d, &AreaData::areaListChanged, this,
+            &CircularGenerator::onAreaListChanged);
+    onAreaListChanged();
+  }
+}
+
+void CircularGenerator::init() {
+  connect(this->distance(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this->deltaAlpha(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this->minLength(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this, &CircularGenerator::referenceChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this, &CircularGenerator::dataChanged, this,
+          &CircularGenerator::onDataChanged);
+  onDataChanged();
+  setName(tr("Circular Generator"));
 }
 
 void CircularGenerator::setMeasurementArea(MeasurementArea *area) {

src/MeasurementComplexItem/CircularGenerator.h

@@ -20,11 +20,11 @@ public:
   Q_PROPERTY(Fact *deltaAlpha READ deltaAlpha CONSTANT)
   Q_PROPERTY(Fact *minLength READ minLength CONSTANT)
 
-  virtual QString editorQml() override;
-  virtual QString mapVisualQml() override;
+  virtual QString editorQml() const override;
+  virtual QString mapVisualQml() const override;
 
-  virtual QString abbreviation() override;
-  virtual QString type() override;
+  virtual QString abbreviation() const override;
+  virtual QString type() const override;
 
   virtual bool get(Generator &generator) override;
 
@@ -47,6 +47,7 @@ public:
   virtual bool load(const QJsonObject &obj, QString &guiErrorMessage) override;
 
   static const char *settingsGroup;
+  static const char *typeString;
 
 signals:
   void referenceChanged();
@@ -55,8 +56,12 @@ public slots:
   Q_INVOKABLE void resetReferenceIfInvalid();
   Q_INVOKABLE void resetReference();
 
-private:
+private slots:
   void onAreaListChanged();
+  void onDataChanged();
+
+private:
+  void init();
   void setMeasurementArea(MeasurementArea *area);
 
   QGeoCoordinate _reference;

src/MeasurementComplexItem/GeneratorBase.cc

@@ -11,20 +11,18 @@ GeneratorBase::GeneratorBase(QObject *parent)
     : GeneratorBase(nullptr, parent) {}
 
 GeneratorBase::GeneratorBase(GeneratorBase::Data d, QObject *parent)
-    : QObject(parent), _d(d) {
-  establishConnections();
-}
+    : QObject(parent), _d(d) {}
 
 GeneratorBase::~GeneratorBase() {}
 
 bool GeneratorBase::save(QJsonObject &obj) const {
-  obj[typeKey] = type();
-  obj[name] = name();
+  obj[typeKey] = this->type();
+  obj[nameKey] = this->name();
   return true;
 }
 
 bool GeneratorBase::load(const QJsonObject &obj, QString &errorString) {
-  if (obj.contains[nameKey] && obj[nameKey].isString()) {
+  if (obj.contains(nameKey) && obj[nameKey].isString()) {
     setName(obj[nameKey].toString());
     return true;
   } else {
@@ -46,18 +44,12 @@ void GeneratorBase::setName(const QString &name) {
 GeneratorBase::Data GeneratorBase::data() const { return _d; }
 
 void GeneratorBase::setData(Data d) {
-  if (d != _d && d != nullptr) {
-    deleteConnections();
+  if (d != _d) {
     _d = d;
-    establishConnections();
     emit dataChanged();
   }
 }
 
-void GeneratorBase::establishConnections() {}
-
-void GeneratorBase::deleteConnections() {}
-
 GeneratorFactory::GeneratorFactory() {}
 
 GeneratorFactory *GeneratorFactory::createInstance() {
@@ -112,14 +104,14 @@ GeneratorBase *GeneratorFactory::create(const QJsonObject &jsonGenerator,
         return nullptr;
       }
     } else {
-      errorMessage.append(QObject::tr("Not able to create generator of type") +
-                          " " +
+      errorMessage.append(
+          QObject::tr("Not able to create generator of type.\n") + " " +
           jsonGenerator[GeneratorBase::typeKey].toString());
       return nullptr;
     }
   } else {
     errorMessage.append(QObject::tr(
-        "Not able to load Generator. Impossible to determine type."));
+        "Not able to load Generator. Impossible to determine type.\n"));
     return nullptr;
   }
 }

src/MeasurementComplexItem/GeneratorBase.h

@@ -53,8 +53,6 @@ signals:
   void nameChanged();
 
 protected:
-  virtual void establishConnections();
-  virtual void deleteConnections();
   Data _d;
   QString _name;
 
@@ -87,7 +85,7 @@ private:
 
 #define REGISTER_GENERATOR(type, creator)                                      \
   namespace {                                                                  \
-  auto registered_##type =                                                     \
+  auto registered =                                                            \
       GeneratorFactory::instance() -> registerGenerator(type, creator);        \
   }
 } // namespace routing

src/MeasurementComplexItem/LinearGenerator.cpp

@@ -14,8 +14,6 @@
 namespace routing {
 
 namespace {
-const QString generatorType = "LinearGenerator";
-
 GeneratorBase *creator(QObject *parent) { return new LinearGenerator(parent); }
 
 const char *distanceKey = "TransectDistance";
@@ -23,7 +21,6 @@ const char *alphaKey = "Alpha";
 const char *minLengthKey = "MinLength";
 } // namespace
 
-REGISTER_GENERATOR(generatorType, creator)
 QGC_LOGGING_CATEGORY(LinearGeneratorLog, "LinearGeneratorLog")
 
 bool linearTransects(const snake::FPolygon &polygon,
@@ -32,9 +29,20 @@ bool linearTransects(const snake::FPolygon &polygon,
                      snake::Length minLength, snake::Transects &transects);
 
 const char *LinearGenerator::settingsGroup = "LinearGenerator";
+const char *LinearGenerator::typeString = "LinearGenerator";
+
+REGISTER_GENERATOR("LinearGenerator", creator)
 
 LinearGenerator::LinearGenerator(QObject *parent)
-    : LinearGenerator(nullptr, parent) {}
+    : GeneratorBase(nullptr, parent),
+      _metaDataMap(FactMetaData::createMapFromJsonFile(
+          QStringLiteral(":/json/LinearGenerator.SettingsGroup.json"), this)),
+      _distance(settingsGroup, _metaDataMap[distanceKey]),
+      _alpha(settingsGroup, _metaDataMap[alphaKey]),
+      _minLength(settingsGroup, _metaDataMap[minLengthKey]),
+      _measurementArea(nullptr) {
+  init();
+}
 
 LinearGenerator::LinearGenerator(GeneratorBase::Data d, QObject *parent)
     : GeneratorBase(d, parent),
@@ -43,30 +51,24 @@ LinearGenerator::LinearGenerator(GeneratorBase::Data d, QObject *parent)
       _distance(settingsGroup, _metaDataMap[distanceKey]),
       _alpha(settingsGroup, _metaDataMap[alphaKey]),
       _minLength(settingsGroup, _metaDataMap[minLengthKey]),
-      _measurementArea(nullptr), _safeArea(nullptr) {
-  connect(this->distance(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->alpha(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->minLength(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->_d, &AreaData::areaListChanged, this,
-          &LinearGenerator::onAreaListChanged);
-  setName(tr("Linear Generator"));
+      _measurementArea(nullptr) {
+  init();
 }
 
-QString LinearGenerator::editorQml() {