RouteComplexItem.cc

#include "RouteComplexItem.h"

#include "CircularGenerator.h"
#include "LinearGenerator.h"
#include "RoutingThread.h"
#include "geometry/GenericCircle.h"
#include "geometry/MeasurementArea.h"
#include "geometry/SafeArea.h"
#include "geometry/clipper/clipper.hpp"
#include "geometry/snake.h"
#include "nemo_interface/SnakeTile.h"

// QGC
#include "JsonHelper.h"
#include "QGCApplication.h"
#include "QGCLoggingCategory.h"

// boost
#include <boost/units/io.hpp>
#include <boost/units/systems/si.hpp>

#define CLIPPER_SCALE 1000000

QGC_LOGGING_CATEGORY(RouteComplexItemLog, "RouteComplexItemLog")

template <typename T>
constexpr typename std::underlying_type<T>::type integral(T value) {
  return static_cast<typename std::underlying_type<T>::type>(value);
}

const char *RouteComplexItem::settingsGroup = "Route";
const char *RouteComplexItem::jsonComplexItemTypeValue = "Route";
const char *RouteComplexItem::variantName = "Variant";
const QString RouteComplexItem::name(tr("Route"));

RouteComplexItem::RouteComplexItem(PlanMasterController *masterController,
                                   bool flyView, const QString &kmlOrShpFile,
                                   QObject *parent)
    : TransectStyleComplexItem(masterController, flyView, settingsGroup,
                               parent),
      _state(STATE::IDLE),
      _metaDataMap(FactMetaData::createMapFromJsonFile(
          QStringLiteral(":/json/RouteComplexItem.SettingsGroup.json"), this)),
      _variant(settingsGroup, _metaDataMap[variantName]),
      _areaData(new AreaData(this)), _editorData(new AreaData(this)),
      _currentData(_areaData), _pWorker(new RoutingThread(this)) {

  Q_UNUSED(kmlOrShpFile)
  _editorQml = "qrc:/qml/CircularSurveyItemEditor.qml";

  // Connect facts.
  connect(&this->_variant, &Fact::rawValueChanged, this,
          &RouteComplexItem::_changeVariant);

  // Connect worker.
  connect(this->_pWorker, &RoutingThread::result, this,
          &RouteComplexItem::_setTransects);
  connect(this->_pWorker, &RoutingThread::calculatingChanged, this,
          &RouteComplexItem::calculatingChanged);

  // Register Generators.
  auto lg = new routing::LinearGenerator(this->_areaData, this);
  registerGenerator(lg->name(), lg);
  auto cg = new routing::CircularGenerator(this->_areaData, this);
  registerGenerator(cg->name(), cg);
}

RouteComplexItem::~RouteComplexItem() {}

void RouteComplexItem::revertPath() {
  this->_setState(STATE::REVERT_PATH);
  this->_rebuildTransects();
}

const AreaData *RouteComplexItem::areaData() const {
  return this->_currentData;
}

AreaData *RouteComplexItem::areaData() { return this->_currentData; }

QStringList RouteComplexItem::variantNames() const { return _variantNames; }

bool RouteComplexItem::load(const QJsonObject &complexObject,
                            int sequenceNumber, QString &errorString) {
  // We need to pull version first to determine what validation/conversion
  // needs to be performed
  QList<JsonHelper::KeyValidateInfo> versionKeyInfoList = {
      {JsonHelper::jsonVersionKey, QJsonValue::Double, true},
  };
  if (!JsonHelper::validateKeys(complexObject, versionKeyInfoList,
                                errorString)) {
    return false;
  }

  int version = complexObject[JsonHelper::jsonVersionKey].toInt();
  if (version != 1) {
    errorString = tr("Survey items do not support version %1").arg(version);
    return false;
  }

  QList<JsonHelper::KeyValidateInfo> keyInfoList = {
      {VisualMissionItem::jsonTypeKey, QJsonValue::String, true},
      {ComplexMissionItem::jsonComplexItemTypeKey, QJsonValue::String, true},
      {variantName, QJsonValue::Double, false},
  };

  if (!JsonHelper::validateKeys(complexObject, keyInfoList, errorString)) {
    return false;
  }

  QString itemType = complexObject[VisualMissionItem::jsonTypeKey].toString();
  QString complexType =
      complexObject[ComplexMissionItem::jsonComplexItemTypeKey].toString();
  if (itemType != VisualMissionItem::jsonTypeComplexItemValue ||
      complexType != jsonComplexItemTypeValue) {
    errorString = tr("%1 does not support loading this complex mission item "
                     "type: %2:%3")
                      .arg(qgcApp()->applicationName())
                      .arg(itemType)
                      .arg(complexType);
    return false;
  }

  _ignoreRecalc = true;

  setSequenceNumber(sequenceNumber);

  if (!_surveyAreaPolygon.loadFromJson(complexObject, true /* required */,
                                       errorString)) {
    _surveyAreaPolygon.clear();
    return false;
  }

  if (!load(complexObject, sequenceNumber, errorString)) {
    _ignoreRecalc = false;
    return false;
  }

  _variant.setRawValue(complexObject[variantName].toInt());

  _ignoreRecalc = false;

  if (_cameraShots == 0) {
    // Shot count was possibly not available from plan file
    _recalcCameraShots();
  }

  return true;
}

QString RouteComplexItem::mapVisualQML() const {
  return QStringLiteral("CircularSurveyMapVisual.qml");
}

void RouteComplexItem::save(QJsonArray &planItems) {
  QJsonObject saveObject;

  _save(saveObject);

  saveObject[JsonHelper::jsonVersionKey] = 1;
  saveObject[VisualMissionItem::jsonTypeKey] =
      VisualMissionItem::jsonTypeComplexItemValue;
  saveObject[ComplexMissionItem::jsonComplexItemTypeKey] =
      jsonComplexItemTypeValue;

  saveObject[variantName] = double(_variant.rawValue().toUInt());

  // Polygon shape
  _surveyAreaPolygon.saveToJson(saveObject);

  planItems.append(saveObject);
}

bool RouteComplexItem::specifiesCoordinate() const {
  return _transects.count() > 0 ? _transects.first().count() > 0 : false;
}

bool RouteComplexItem::_setGenerator(PtrGenerator newG) {
  if (this->_pGenerator != newG) {
    if (this->_pGenerator != nullptr) {
      disconnect(this->_pGenerator, &routing::GeneratorBase::generatorChanged,
                 this, &RouteComplexItem::_rebuildTransects);
    }

    this->_pGenerator = newG;
    connect(this->_pGenerator, &routing::GeneratorBase::generatorChanged, this,
            &RouteComplexItem::_rebuildTransects);
    emit generatorChanged();

    this->_setState(STATE::IDLE);
    _rebuildTransects();

    return true;
  } else {
    return false;
  }
}

void RouteComplexItem::_setState(RouteComplexItem::STATE state) {
  if (this->_state != state) {
    auto oldState = this->_state;
    this->_state = state;
    if (_calculating(oldState) != _calculating(state)) {
      emit calculatingChanged();
    }
  }
}

bool RouteComplexItem::_calculating(RouteComplexItem::STATE state) const {
  return state == STATE::ROUTING;
}

void RouteComplexItem::_setEditing(bool editing) {
  if (editing != _editing) {
    _editing = editing;
    emit editingChanged();
  }
}

void RouteComplexItem::_setAreaData(RouteComplexItem::PtrAreaData data) {
  if (_currentData != data) {
    _currentData = data;
    emit areaDataChanged();
  }
}

void RouteComplexItem::_changeVariant() {
  this->_setState(STATE::CHANGE_VARIANT);
  this->_rebuildTransects();
}

bool RouteComplexItem::_updateWorker() {
  // Reset data.
  this->_transects.clear();
  this->_variantVector.clear();
  this->_variantNames.clear();
  emit variantNamesChanged();

  if (this->_areaData->isValid()) {

    // Prepare data.
    auto origin = this->_areaData->origin();
    origin.setAltitude(0);
    if (!origin.isValid()) {
      qCDebug(RouteComplexItemLog)
          << "_updateWorker(): origin invalid." << origin;
      return false;
    }

    // Convert safe area.
    auto serviceArea =
        getGeoArea<const SafeArea *>(*this->_areaData->areaList());
    auto geoSafeArea = serviceArea->coordinateList();
    if (!(geoSafeArea.size() >= 3)) {
      qCDebug(RouteComplexItemLog)
          << "_updateWorker(): safe area invalid." << geoSafeArea;
      return false;
    }
    for (auto &v : geoSafeArea) {
      if (v.isValid()) {
        v.setAltitude(0);
      } else {
        qCDebug(RouteComplexItemLog)
            << "_updateWorker(): safe area contains invalid coordinate."
            << geoSafeArea;
        return false;
      }
    }

    // Routing par.
    RoutingParameter par;
    par.numSolutions = 5;
    auto &safeAreaENU = par.safeArea;
    snake::areaToEnu(origin, geoSafeArea, safeAreaENU);

    // Create generator.
    if (this->_pGenerator) {
      routing::GeneratorBase::Generator g; // Transect generator.
      if (this->_pGenerator->get(g)) {
        // Start/Restart routing worker.
        this->_pWorker->route(par, g);
        return true;
      } else {
        qCDebug(RouteComplexItemLog)
            << "_updateWorker(): generator creation failed.";
        return false;
      }
    } else {
      qCDebug(RouteComplexItemLog)
          << "_updateWorker(): pGenerator == nullptr, number of registered "
             "generators: "
          << this->_generatorList.size();
      return false;
    }
  } else {
    qCDebug(RouteComplexItemLog) << "_updateWorker(): plan data invalid.";
    return false;
  }
}

void RouteComplexItem::_changeVariantWorker() {
  auto variant = this->_variant.rawValue().toUInt();

  // Find old variant and run. Old run corresponts with empty list.
  std::size_t old_variant = std::numeric_limits<std::size_t>::max();
  for (std::size_t i = 0; i < std::size_t(this->_variantVector.size()); ++i) {
    const auto &variantCoordinates = this->_variantVector.at(i);
    if (variantCoordinates.isEmpty()) {
      old_variant = i;
      break;
    }
  }

  // Swap route.
  if (variant != old_variant) {
    // Swap in new variant.
    if (variant < std::size_t(this->_variantVector.size())) {
      if (old_variant != std::numeric_limits<std::size_t>::max()) {
        // this->_transects containes a route, swap it back to
        // this->_solutionVector
        auto &oldVariantCoordinates = this->_variantVector[old_variant];
        oldVariantCoordinates.swap(this->_transects);
      }
      auto &newVariantCoordinates = this->_variantVector[variant];
      this->_transects.swap(newVariantCoordinates);

    } else { // error
      qCDebug(RouteComplexItemLog)
          << "Variant out of bounds (variant =" << variant << ").";
      qCDebug(RouteComplexItemLog) << "Resetting variant to zero.";

      disconnect(&this->_variant, &Fact::rawValueChanged, this,
                 &RouteComplexItem::_changeVariant);
      this->_variant.setCookedValue(QVariant(0));
      connect(&this->_variant, &Fact::rawValueChanged, this,
              &RouteComplexItem::_changeVariant);

      if (this->_variantVector.size() > 0) {
        this->_changeVariantWorker();
      }
    }
  }
}

void RouteComplexItem::_reverseWorker() {
  if (this->_transects.size() > 0) {
    auto &t = this->_transects.front();
    std::reverse(t.begin(), t.end());
  }
}

double RouteComplexItem::timeBetweenShots() { return 0; }

QString RouteComplexItem::commandDescription() const { return tr("Route"); }

QString RouteComplexItem::commandName() const { return tr("Route"); }

QString RouteComplexItem::abbreviation() const { return tr("R"); }

TransectStyleComplexItem::ReadyForSaveState
RouteComplexItem::readyForSaveState() const {
  if (TransectStyleComplexItem::readyForSaveState() ==
      TransectStyleComplexItem::ReadyForSaveState::ReadyForSave) {
    if (this->_state == STATE::IDLE) {
      return ReadyForSaveState::ReadyForSave;
    } else {
      return ReadyForSaveState::NotReadyForSaveData;
    }
  } else {
    return TransectStyleComplexItem::readyForSaveState();
  }
}

double RouteComplexItem::additionalTimeDelay() const { return 0; }

QString RouteComplexItem::patternName() const { return name; }

bool RouteComplexItem::registerGenerator(const QString &name,
                                         routing::GeneratorBase *g) {
  if (name.isEmpty()) {
    qCDebug(RouteComplexItemLog) << "registerGenerator(): empty name string.";
    return false;
  }

  if (!g) {
    qCDebug(RouteComplexItemLog) << "registerGenerator(): empty generator.";
    return false;
  }

  if (this->_generatorNameList.contains(name)) {
    qCDebug(RouteComplexItemLog) << "registerGenerator(): generator "
                                    "already registered.";
    return false;
  } else {
    this->_generatorNameList.push_back(name);
    this->_generatorList.push_back(g);
    if (this->_generatorList.size() == 1) {
      _setGenerator(g);
    }

    emit generatorNameListChanged();
    return true;
  }
}

bool RouteComplexItem::unregisterGenerator(const QString &name) {
  auto index = this->_generatorNameList.indexOf(name);
  if (index >= 0) {
    // Is this the current generator?
    const auto &g = this->_generatorList.at(index);
    if (g == this->_pGenerator) {
      if (index > 0) {
        _setGenerator(this->_generatorList.at(index - 1));
      } else {
        _setGenerator(nullptr);
        qCDebug(RouteComplexItemLog)
            << "unregisterGenerator(): last generator unregistered.";
      }
    }

    this->_generatorNameList.removeAt(index);
    auto gen = this->_generatorList.takeAt(index);
    gen->deleteLater();

    emit generatorNameListChanged();
    return true;
  } else {
    qCDebug(RouteComplexItemLog)
        << "unregisterGenerator(): generator " << name << " not registered.";
    return false;
  }
}

bool RouteComplexItem::unregisterGenerator(int index) {
  if (index > 0 && index < this->_generatorNameList.size()) {
    return unregisterGenerator(this->_generatorNameList.at(index));
  } else {
    qCDebug(RouteComplexItemLog) << "unregisterGenerator(): index (" << index
                                 << ") out"
                                    "of bounds ( "
                                 << this->_generatorList.size() << " ).";
    return false;
  }
}

bool RouteComplexItem::switchToGenerator(const QString &name) {
  auto index = this->_generatorNameList.indexOf(name);
  if (index >= 0) {
    _setGenerator(this->_generatorList.at(index));
    return true;
  } else {
    qCDebug(RouteComplexItemLog)
        << "switchToGenerator(): generator " << name << " not registered.";
    return false;
  }
}

bool RouteComplexItem::switchToGenerator(int index) {
  if (index >= 0) {
    _setGenerator(this->_generatorList.at(index));
    return true;
  } else {
    qCDebug(RouteComplexItemLog) << "unregisterGenerator(): index (" << index
                                 << ") out"
                                    "of bounds ( "
                                 << this->_generatorNameList.size() << " ).";
    return false;
  }
}

QStringList RouteComplexItem::generatorNameList() {
  return this->_generatorNameList;
}

routing::GeneratorBase *RouteComplexItem::generator() { return _pGenerator; }

int RouteComplexItem::generatorIndex() {
  return this->_generatorList.indexOf(this->_pGenerator);
}

void RouteComplexItem::editingStart() {
  if (!_editing) {
    *_editorData = *_areaData;
    _setAreaData(_editorData);
    _setEditing(true);
  }
}

void RouteComplexItem::editingStop() {
  if (_editing) {
    if (_editorData->isValid()) {
      *_areaData = *_editorData;
    }
    _setAreaData(_areaData);
    _setEditing(false);
  }
}

void RouteComplexItem::_rebuildTransectsPhase1(void) {
  auto start = std::chrono::high_resolution_clock::now();

  switch (this->_state) {
  case STATE::SKIPP:
    qCDebug(RouteComplexItemLog) << "rebuildTransectsPhase1: skipp.";
    this->_setState(STATE::IDLE);
    break;
  case STATE::CHANGE_VARIANT:
    qCDebug(RouteComplexItemLog) << "rebuildTransectsPhase1: variant change.";
    this->_changeVariantWorker();
    this->_setState(STATE::IDLE);
    break;
  case STATE::REVERT_PATH:
    qCDebug(RouteComplexItemLog) << "rebuildTransectsPhase1: reverse.";
    this->_reverseWorker();
    this->_setState(STATE::IDLE);
    break;
  case STATE::IDLE:
  case STATE::ROUTING:
    this->_setState(STATE::ROUTING);
    qCDebug(RouteComplexItemLog) << "rebuildTransectsPhase1: update.";
    if (!this->_updateWorker()) {
      this->_setState(STATE::IDLE);
    }
    break;
  }

  qCDebug(RouteComplexItemLog)
      << "rebuildTransectsPhase1(): "
      << std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::high_resolution_clock::now() - start)
             .count()
      << " ms";
}

void RouteComplexItem::_recalcCameraShots() { _cameraShots = 0; }

void RouteComplexItem::_setTransects(RouteComplexItem::PtrRoutingData pRoute) {
  // Store solutions.
  auto ori = this->_areaData->origin();
  ori.setAltitude(0);
  const auto &transectsENU = pRoute->transects;
  QVector<Variant> variantVector;
  const auto nSolutions = pRoute->solutionVector.size();

  for (std::size_t j = 0; j < nSolutions; ++j) {
    Variant var{QList<CoordInfo_t>()};
    const auto &solution = pRoute->solutionVector.at(j);
    if (solution.size() > 0) {
      const auto &route = solution.at(0);
      const auto &path = route.path;
      const auto &info = route.info;
      if (info.size() > 1) {
        // Find index of first waypoint.
        std::size_t idxFirst = 0;
        const auto &infoFirst = info.at(1);
        const auto &firstTransect = transectsENU[infoFirst.index];
        if (firstTransect.size() > 0) {
          const auto &firstWaypoint =
              infoFirst.reversed ? firstTransect.back() : firstTransect.front();
          double th = 0.01;
          for (std::size_t i = 0; i < path.size(); ++i) {
            auto dist = bg::distance(path[i], firstWaypoint);
            if (dist < th) {
              idxFirst = i;
              break;
            }
          }

          // Find index of last waypoint.
          std::size_t idxLast = path.size() - 1;
          const auto &infoLast = info.at(info.size() - 2);
          const auto &lastTransect = transectsENU[infoLast.index];
          if (lastTransect.size() > 0) {
            const auto &lastWaypoint =
                infoLast.reversed ? lastTransect.front() : lastTransect.back();
            for (long i = path.size() - 1; i >= 0; --i) {
              auto dist = bg::distance(path[i], lastWaypoint);
              if (dist < th) {
                idxLast = i;
                break;
              }
            }

            // Convert to geo coordinates.
            auto &list = var.front();
            for (std::size_t i = idxFirst; i <= idxLast; ++i) {
              auto &vertex = path[i];
              QGeoCoordinate c;
              snake::fromENU(ori, vertex, c);
              list.append(CoordInfo_t{c, CoordTypeInterior});
            }

          } else {
            qCDebug(RouteComplexItemLog)
                << "_setTransects(): lastTransect.size() == 0";
          }
        } else {
          qCDebug(RouteComplexItemLog)
              << "_setTransects(): firstTransect.size() == 0";
        }
      } else {
        qCDebug(RouteComplexItemLog)
            << "_setTransects(): transectsInfo.size() <= 1";
      }
    } else {
      qCDebug(RouteComplexItemLog) << "_setTransects(): solution.size() == 0";
    }

    if (var.size() > 0 && var.front().size() > 0) {
      variantVector.push_back(std::move(var));
    }
  }

  // Assign routes if no error occured.
  if (variantVector.size() > 0) {
    // Swap first route to _transects.
    this->_variantVector.swap(variantVector);

    // If the transects are getting rebuilt then any previously loaded
    // mission items are now invalid.
    if (_loadedMissionItemsParent) {
      _loadedMissionItems.clear();
      _loadedMissionItemsParent->deleteLater();
      _loadedMissionItemsParent = nullptr;
    }

    // Add route variant names.
    this->_variantNames.clear();
    for (std::size_t i = 1; i <= std::size_t(this->_variantVector.size());
         ++i) {
      this->_variantNames.append(QString::number(i));
    }
    emit variantNamesChanged();

    disconnect(&this->_variant, &Fact::rawValueChanged, this,
               &RouteComplexItem::_changeVariant);
    this->_variant.setCookedValue(QVariant(0));
    connect(&this->_variant, &Fact::rawValueChanged, this,
            &RouteComplexItem::_changeVariant);
    this->_changeVariantWorker();

    this->_setState(STATE::SKIPP);
    this->_rebuildTransects();
  } else {
    qCDebug(RouteComplexItemLog)
        << "_setTransects(): failed, variantVector empty.";
    this->_setState(STATE::IDLE);
  }
}

Fact *RouteComplexItem::variant() { return &_variant; }

bool RouteComplexItem::calculating() const {
  return this->_calculating(this->_state);
}

bool RouteComplexItem::editing() const { return this->_editing; }