WimaMeasurementArea.cc

#include "WimaMeasurementArea.h"
#include "QtConcurrentRun"
#include "SnakeTile.h"
#include "snake.h"

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

#include "QGCLoggingCategory.h"

#ifndef SNAKE_MAX_TILES
#define SNAKE_MAX_TILES 1000
#endif

QGC_LOGGING_CATEGORY(WimaMeasurementAreaLog, "WimaMeasurementAreaLog")

TileData::TileData() : tiles(this) {}

TileData::~TileData() { tiles.clearAndDeleteContents(); }

TileData &TileData::operator=(const TileData &other) {
  this->tiles.clearAndDeleteContents();
  for (std::size_t i = 0; i < std::size_t(other.tiles.count()); ++i) {
    const auto *obj = other.tiles.get(i);
    const auto *tile = qobject_cast<const SnakeTile *>(obj);
    if (tile != nullptr) {
      this->tiles.append(new SnakeTile(*tile, this));
    } else {
      qCWarning(WimaMeasurementAreaLog) << "TileData::operator=: nullptr";
    }
  }
  this->tileCenterPoints = other.tileCenterPoints;
  return *this;
}

bool TileData::operator==(const TileData &other) const {
  return this->tiles == other.tiles &&
         this->tileCenterPoints == other.tileCenterPoints;
}

bool TileData::operator!=(const TileData &other) const {
  return !this->operator==(other);
}

void TileData::clear() {
  this->tiles.clearAndDeleteContents();
  this->tileCenterPoints.clear();
}

size_t TileData::size() const {
  if (tiles.count() == tileCenterPoints.size()) {
    return tiles.count();
  } else {
    return 0;
  }
}

const char *WimaMeasurementArea::settingsGroup = "MeasurementArea";
const char *WimaMeasurementArea::tileHeightName = "TileHeight";
const char *WimaMeasurementArea::tileWidthName = "TileWidth";
const char *WimaMeasurementArea::minTileAreaName = "MinTileAreaPercent";
const char *WimaMeasurementArea::showTilesName = "ShowTiles";
const char *WimaMeasurementArea::WimaMeasurementAreaName = "Measurement Area";

WimaMeasurementArea::WimaMeasurementArea(QObject *parent)
    : WimaArea(parent),
      _metaDataMap(FactMetaData::createMapFromJsonFile(
          QStringLiteral(":/json/WimaMeasurementArea.SettingsGroup.json"),
          this /* QObject parent */)),
      _tileHeight(SettingsFact(settingsGroup, _metaDataMap[tileHeightName],
                               this /* QObject parent */)),
      _tileWidth(SettingsFact(settingsGroup, _metaDataMap[tileWidthName],
                              this /* QObject parent */)),
      _minTileAreaPercent(SettingsFact(settingsGroup,
                                       _metaDataMap[minTileAreaName],
                                      this /* QObject parent */)),
      _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                              this /* QObject parent */)),
      _state(STATE::IDLE) {
  init();
}

WimaMeasurementArea::WimaMeasurementArea(const WimaMeasurementArea &other,
                                         QObject *parent)
    : WimaArea(other, parent),
      _metaDataMap(FactMetaData::createMapFromJsonFile(
          QStringLiteral(":/json/WimaMeasurementArea.SettingsGroup.json"),
          this /* QObject parent */)),
      _tileHeight(SettingsFact(settingsGroup, _metaDataMap[tileHeightName],
                               this /* QObject parent */)),
      _tileWidth(SettingsFact(settingsGroup, _metaDataMap[tileWidthName],
                              this /* QObject parent */)),
      _minTileAreaPercent(SettingsFact(settingsGroup,
                                       _metaDataMap[minTileAreaName],
                                      this /* QObject parent */)),
      _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                              this /* QObject parent */)),
      _state(STATE::IDLE) {
  init();
}

/*!
 * \overload operator=()
 *
 * Calls the inherited operator WimaArea::operator=().
 */
WimaMeasurementArea &WimaMeasurementArea::
operator=(const WimaMeasurementArea &other) {
  WimaArea::operator=(other);
  return *this;
}

WimaMeasurementArea::~WimaMeasurementArea() {}

QString WimaMeasurementArea::mapVisualQML() const {
  return QStringLiteral("WimaMeasurementAreaMapVisual.qml");
}

QString WimaMeasurementArea::editorQML() const {
  return QStringLiteral("WimaMeasurementAreaEditor.qml");
}

Fact *WimaMeasurementArea::tileHeight() { return &_tileHeight; }

Fact *WimaMeasurementArea::tileWidth() { return &_tileWidth; }

Fact *WimaMeasurementArea::minTileArea() { return &_minTileAreaPercent; }

Fact *WimaMeasurementArea::showTiles() { return &_showTiles; }

QmlObjectListModel *WimaMeasurementArea::tiles() {
  return &this->_tileData.tiles;
}

const QVector<int> &WimaMeasurementArea::progress() const {
  return this->_progress;
}

QVector<int> WimaMeasurementArea::progressQml() const {
  return this->_progress;
}

const QmlObjectListModel *WimaMeasurementArea::tiles() const {
  return &this->_tileData.tiles;
}

const QVariantList &WimaMeasurementArea::tileCenterPoints() const {
  return this->_tileData.tileCenterPoints;
}

const TileData &WimaMeasurementArea::tileData() const {
  return this->_tileData;
}

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] = _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)) {
    disableUpdate();
    bool retVal = true;

    if (!json.contains(tileHeightName) || !json[tileHeightName].isDouble()) {
      errorString.append(tr("Could not load tile height!\n"));
      retVal = false;
    } else {
      _tileHeight.setRawValue(json[tileHeightName].toDouble());
    }

    if (!json.contains(tileWidthName) || !json[tileWidthName].isDouble()) {
      errorString.append(tr("Could not load tile width!\n"));
      retVal = false;
    } else {
      _tileWidth.setRawValue(json[tileWidthName].toDouble());
    }

    if (!json.contains(minTileAreaName) || !json[minTileAreaName].isDouble()) {
      errorString.append(tr("Could not load minimal tile area!\n"));
      retVal = false;
    } else {
      _minTileAreaPercent.setRawValue(json[minTileAreaName].toDouble());
    }

    if (!json.contains(showTilesName) || !json[showTilesName].isBool()) {
      errorString.append(tr("Could not load show tiles !\n"));
      retVal = false;
    } else {
      _showTiles.setRawValue(json[showTilesName].toBool());
    }

    enableUpdate();
    doUpdate();

    return retVal;
  } else {
    return false;
  }
}

bool WimaMeasurementArea::setProgress(const QVector<int> &p) {
  if (ready()) {
    if (p.size() == this->tiles()->count() && this->_progress != p) {
      this->_progress = p;
      emit progressChanged();
      emit progressAccepted();
      return true;
    }
  }
  return false;
}
//!
//! \brief WimaMeasurementArea::doUpdate
//! \pre WimaMeasurementArea::deferUpdate must be called first, don't call
//! this function directly!
void WimaMeasurementArea::doUpdate() {
  using namespace snake;
  using namespace boost::units;

  auto start = std::chrono::high_resolution_clock::now();

  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;
    // Check some conditions.
    if (long(std::ceil(estNumTiles.value())) <= SNAKE_MAX_TILES &&
      this->count() >= 3 && this->isSimplePolygon()) {
      setState(STATE::UPDATEING);

    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));
        }
      }
      pData->moveToThread(th);

      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()

    this->_watcher.setFuture(future);
  }
  }
  qCDebug(WimaMeasurementAreaLog)
      << "doUpdate(): execution time: "
      << std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::high_resolution_clock::now() - start)
             .count()
      << " ms";
}

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();
      emit this->progressChanged();
      emit this->tilesChanged();
    }
    this->setState(STATE::DEFERED);
    this->_timer.start(100);
  } 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::UPDATEING) {
    qCDebug(WimaMeasurementAreaLog) << "storeTiles(): update.";

    this->_tileData = *this->_watcher.result();
    // This is expensive. Drawing tiles is expensive too.
    this->_progress = QVector<int>(this->_tileData.tiles.count(), 0);
    this->progressChanged();
    emit this->tilesChanged();
    setState(STATE::IDLE);
  } 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: "
      << std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::high_resolution_clock::now() - start)
             .count()
      << " ms";
}

void WimaMeasurementArea::disableUpdate() {
  setState(STATE::IDLE);
  this->_timer.stop();
}

void WimaMeasurementArea::enableUpdate() {
  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->_minTileAreaPercent, &Fact::rawValueChanged, this,
          &WimaMeasurementArea::deferUpdate);
  connect(this, &WimaArea::pathChanged, this,
          &WimaMeasurementArea::deferUpdate);
  this->_timer.setSingleShot(true);
  connect(&this->_timer, &QTimer::timeout, this,
          &WimaMeasurementArea::doUpdate);
  connect(&this->_watcher,
          &QFutureWatcher<std::unique_ptr<QmlObjectListModel>>::finished, this,
          &WimaMeasurementArea::storeTiles);
}

void WimaMeasurementArea::setState(WimaMeasurementArea::STATE s) {
  if (this->_state != s) {
    auto oldState = this->_state;
    this->_state = s;
    if (s == STATE::IDLE || oldState == STATE::IDLE) {
      emit readyChanged();
    }
  }
}

/*!
 * \class WimaMeasurementArea
 * \brief Class defining the area inside which the actual drone measurements
 * are performed.
 *
 * \sa WimaArea, WimaController, WimaPlaner
 */