diff --git a/qgroundcontrol.pro b/qgroundcontrol.pro
index 48437a64d07d8ae4d3915c4d53da697e79015271..1976dc21c74182e5ec2c75cf3c57876ba50d05fb 100644
--- a/qgroundcontrol.pro
+++ b/qgroundcontrol.pro
@@ -423,6 +423,7 @@ INCLUDEPATH += \
     src/comm \
     src/MeasurementComplexItem \
     src/MeasurementComplexItem/geometry \
+    src/MeasurementComplexItem/nemo_interface \
     src/comm/ros_bridge \
     src/input \
     src/lib/qmapcontrol \
diff --git a/src/MeasurementComplexItem/MeasurementComplexItem.cc b/src/MeasurementComplexItem/MeasurementComplexItem.cc
index abbd0f2be74e021136657c2f0d1b3ffc1144e4d4..b8d879e969335efa44a83a3c503fd7f807d64c6a 100644
--- a/src/MeasurementComplexItem/MeasurementComplexItem.cc
+++ b/src/MeasurementComplexItem/MeasurementComplexItem.cc
@@ -39,14 +39,14 @@ const QString MeasurementComplexItem::name(tr("Measurement"));
 MeasurementComplexItem::MeasurementComplexItem(
     PlanMasterController *masterController, bool flyView,
     const QString &kmlOrShpFile, QObject *parent)
-    : ComplexMissionItem(masterController, flyView, settingsGroup, parent),
+    : ComplexMissionItem(masterController, flyView, parent),
       _masterController(masterController), _sequenceNumber(0),
-      _followTerrain(false), _state(STATE::IDLE),
+      _followTerrain(false),
+      _altitude(settingsGroup, _metaDataMap[altitudeName]), _state(STATE::IDLE),
       _metaDataMap(FactMetaData::createMapFromJsonFile(
           QStringLiteral(":/json/MeasurementComplexItem.SettingsGroup.json"),
           this)),
       _variant(settingsGroup, _metaDataMap[variantName]),
-      _variant(settingsGroup, _metaDataMap[altitudeName]),
       _areaData(new AreaData(this)), _editorData(new AreaData(this)),
       _currentData(_areaData), _pWorker(new RoutingThread(this)) {
 
@@ -59,9 +59,17 @@ MeasurementComplexItem::MeasurementComplexItem(
 
   // Connect worker.
   connect(this->_pWorker, &RoutingThread::result, this,
-          &MeasurementComplexItem::_setTransects);
-  connect(this->_pWorker, &RoutingThread::calculatingChanged, this,
-          &MeasurementComplexItem::calculatingChanged);
+          &MeasurementComplexItem::_storeRoutingData);
+
+  // Connect coordinate and exitCoordinate
+  connect(this, &MeasurementComplexItem::routeChanged,
+          [this] { emit this->coordinateChanged(this->coordinate()); });
+  connect(this, &MeasurementComplexItem::routeChanged,
+          [this] { emit this->exitCoordinateChanged(this->exitCoordinate()); });
+  connect(this, &MeasurementComplexItem::routeChanged, [this] {
+    emit this->exitCoordinateSameAsEntryChanged(
+        this->exitCoordinateSameAsEntry());
+  });
 
   // Register Generators.
   auto lg = new routing::LinearGenerator(this->_areaData, this);
@@ -75,10 +83,7 @@ MeasurementComplexItem::MeasurementComplexItem(
 
 MeasurementComplexItem::~MeasurementComplexItem() {}
 
-void MeasurementComplexItem::revertPath() {
-  this->_setState(STATE::REVERT_PATH);
-  this->_update();
-}
+void MeasurementComplexItem::reverseRoute() { _reverseRoute(); }
 
 const AreaData *MeasurementComplexItem::areaData() const {
   return this->_currentData;
@@ -86,12 +91,18 @@ const AreaData *MeasurementComplexItem::areaData() const {
 
 AreaData *MeasurementComplexItem::areaData() { return this->_currentData; }
 
+QVariantList MeasurementComplexItem::route() { return _route; }
+
 QStringList MeasurementComplexItem::variantNames() const {
   return _variantNames;
 }
 
 bool MeasurementComplexItem::load(const QJsonObject &complexObject,
                                   int sequenceNumber, QString &errorString) {
+  qWarning() << "MeasurementComplexItem::load(): area data load missing.";
+  qWarning() << "MeasurementComplexItem::load(): mission item load missing.";
+  qWarning() << "MeasurementComplexItem::load(): add editingStart/Stop.";
+
   // We need to pull version first to determine what validation/conversion
   // needs to be performed
   QList<JsonHelper::KeyValidateInfo> versionKeyInfoList = {
@@ -132,31 +143,15 @@ bool MeasurementComplexItem::load(const QJsonObject &complexObject,
     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());
   _altitude.setRawValue(complexObject[altitudeName].toDouble());
 
-  _ignoreRecalc = false;
-
-  if (_cameraShots == 0) {
-    // Shot count was possibly not available from plan file
-    _recalcCameraShots();
-  }
-
   return true;
 }
 
@@ -171,23 +166,23 @@ QString MeasurementComplexItem::mapVisualQML() const {
 }
 
 void MeasurementComplexItem::save(QJsonArray &planItems) {
-  QJsonObject saveObject;
-
-  _save(saveObject);
+  qWarning() << "MeasurementComplexItem::save(): area data save missing.";
+  qWarning() << "MeasurementComplexItem::save(): mission item save missing.";
 
-  saveObject[JsonHelper::jsonVersionKey] = 1;
-  saveObject[VisualMissionItem::jsonTypeKey] =
-      VisualMissionItem::jsonTypeComplexItemValue;
-  saveObject[ComplexMissionItem::jsonComplexItemTypeKey] =
-      jsonComplexItemTypeValue;
+  if (ready()) {
+    QJsonObject saveObject;
 
-  saveObject[variantName] = double(_variant.rawValue().toUInt());
-  saveObject[altitudeName] = double(_altitude.rawValue().toUInt());
+    saveObject[JsonHelper::jsonVersionKey] = 1;
+    saveObject[VisualMissionItem::jsonTypeKey] =
+        VisualMissionItem::jsonTypeComplexItemValue;
+    saveObject[ComplexMissionItem::jsonComplexItemTypeKey] =
+        jsonComplexItemTypeValue;
 
-  // Polygon shape
-  _surveyAreaPolygon.saveToJson(saveObject);
+    saveObject[variantName] = double(_variant.rawValue().toUInt());
+    saveObject[altitudeName] = double(_altitude.rawValue().toUInt());
 
-  planItems.append(saveObject);
+    planItems.append(saveObject);
+  }
 }
 
 double MeasurementComplexItem::amslEntryAlt() const {
@@ -214,11 +209,13 @@ bool MeasurementComplexItem::specifiesCoordinate() const {
 bool MeasurementComplexItem::specifiesAltitudeOnly() const { return false; }
 
 QGeoCoordinate MeasurementComplexItem::coordinate() const {
-  return this->_route.size() > 0 ? _route.first() : QGeoCoordinate();
+  return this->_route.size() > 0 ? _route.first().value<QGeoCoordinate>()
+                                 : QGeoCoordinate();
 }
 
 QGeoCoordinate MeasurementComplexItem::exitCoordinate() const {
-  return this->_route.size() > 0 ? _route.last() : QGeoCoordinate();
+  return this->_route.size() > 0 ? _route.last().value<QGeoCoordinate>()
+                                 : QGeoCoordinate();
 }
 
 int MeasurementComplexItem::sequenceNumber() const { return _sequenceNumber; }
@@ -237,26 +234,32 @@ double MeasurementComplexItem::specifiedGimbalPitch() {
 
 void MeasurementComplexItem::appendMissionItems(QList<MissionItem *> &items,
                                                 QObject *missionItemParent) {
-  qCDebug(MeasurementComplexItemLog) << "appendMissionItems()";
-
-  int seqNum = this->_sequenceNumber;
-
-  MAV_FRAME mavFrame =
-      followTerrain() ? MAV_FRAME_GLOBAL : MAV_FRAME_GLOBAL_RELATIVE_ALT;
-
-  int transectIndex = 0;
-  for (const auto &vertex : this->_route) {
-    MissionItem *item = new MissionItem(
-        seqNum++, MAV_CMD_NAV_WAYPOINT, mavFrame,
-        0,   // hold time
-        0.0, // No acceptance radius specified
-        0.0, // Pass through waypoint
-        std::numeric_limits<double>::quiet_NaN(), // Yaw unchanged
-        vertex.latitude(), vertex.longitude(), vertex.altitude(),
-        true,  // autoContinue
-        false, // isCurrentItem
-        missionItemParent);
-    items.append(item);
+
+  if (ready()) {
+    qCDebug(MeasurementComplexItemLog) << "appendMissionItems()";
+
+    int seqNum = this->_sequenceNumber;
+
+    MAV_FRAME mavFrame =
+        followTerrain() ? MAV_FRAME_GLOBAL : MAV_FRAME_GLOBAL_RELATIVE_ALT;
+
+    for (const auto &variant : this->_route) {
+      auto vertex = variant.value<QGeoCoordinate>();
+      MissionItem *item = new MissionItem(
+          seqNum++, MAV_CMD_NAV_WAYPOINT, mavFrame,
+          0,   // hold time
+          0.0, // No acceptance radius specified
+          0.0, // Pass through waypoint
+          std::numeric_limits<double>::quiet_NaN(), // Yaw unchanged
+          vertex.latitude(), vertex.longitude(), vertex.altitude(),
+          true,  // autoContinue
+          false, // isCurrentItem
+          missionItemParent);
+      items.append(item);
+    }
+  } else {
+    qCDebug(MeasurementComplexItemLog)
+        << "appendMissionItems(): called while not ready().";
   }
 }
 
@@ -266,7 +269,8 @@ void MeasurementComplexItem::setMissionFlightStatus(
 }
 
 void MeasurementComplexItem::applyNewAltitude(double newAltitude) {
-  this->_altitude->setRawValue(newAltitude);
+  this->_altitude.setRawValue(newAltitude);
+  qWarning() << "applyNewAltitude(): impl. missing.";
 }
 
 double MeasurementComplexItem::additionalTimeDelay() const { return 0; }
@@ -275,16 +279,18 @@ bool MeasurementComplexItem::_setGenerator(PtrGenerator newG) {
   if (this->_pGenerator != newG) {
     if (this->_pGenerator != nullptr) {
       disconnect(this->_pGenerator, &routing::GeneratorBase::generatorChanged,
-                 this, &MeasurementComplexItem::_update);
+                 this, &MeasurementComplexItem::_updateRoute);
     }
 
     this->_pGenerator = newG;
     connect(this->_pGenerator, &routing::GeneratorBase::generatorChanged, this,
-            &MeasurementComplexItem::_update);
+            &MeasurementComplexItem::_updateRoute);
     emit generatorChanged();
 
-    this->_setState(STATE::IDLE);
-    _update();
+    if (!editing()) {
+      this->_setState(STATE::IDLE);
+      _updateRoute();
+    }
 
     return true;
   } else {
@@ -304,14 +310,21 @@ void MeasurementComplexItem::_setState(MeasurementComplexItem::STATE state) {
     if (_editing(oldState) != _editing(state)) {
       emit editingChanged();
     }
+
+    if (_ready(oldState) != _ready(state)) {
+      emit readyChanged();
+    }
   }
 }
 
-bool MeasurementComplexItem::_calculating(
-    MeasurementComplexItem::STATE state) const {
+bool MeasurementComplexItem::_calculating(MeasurementComplexItem::STATE state) {
   return state == STATE::ROUTING;
 }
 
+bool MeasurementComplexItem::_ready(MeasurementComplexItem::STATE state) {
+  return state == STATE::IDLE;
+}
+
 void MeasurementComplexItem::_setAreaData(
     MeasurementComplexItem::PtrAreaData data) {
   if (_currentData != data) {
@@ -320,14 +333,9 @@ void MeasurementComplexItem::_setAreaData(
   }
 }
 
-void MeasurementComplexItem::_changeVariant() {
-  this->_setState(STATE::CHANGE_VARIANT);
-  this->_update();
-}
-
-bool MeasurementComplexItem::_updateRouteWorker() {
+bool MeasurementComplexItem::_updateRoute() {
   // Reset data.
-  this->_transects.clear();
+  this->_route.clear();
   this->_variantVector.clear();
   this->_variantNames.clear();
   emit variantNamesChanged();
@@ -394,78 +402,67 @@ bool MeasurementComplexItem::_updateRouteWorker() {
   }
 }
 
-void MeasurementComplexItem::_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;
+void MeasurementComplexItem::_changeVariant() {
+  if (ready()) {
+    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);
+    // 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->_route containes a route, swap it back to
+          // this->_solutionVector
+          auto &oldVariantCoordinates = this->_variantVector[old_variant];
+          oldVariantCoordinates.swap(this->_route);
+        }
+        auto &newVariantCoordinates = this->_variantVector[variant];
+        this->_route.swap(newVariantCoordinates);
 
-    } else { // error
-      qCDebug(MeasurementComplexItemLog)
-          << "Variant out of bounds (variant =" << variant << ").";
-      qCDebug(MeasurementComplexItemLog) << "Resetting variant to zero.";
+      } else { // error
+        qCDebug(MeasurementComplexItemLog)
+            << "Variant out of bounds (variant =" << variant << ").";
+        qCDebug(MeasurementComplexItemLog) << "Resetting variant to zero.";
 
-      disconnect(&this->_variant, &Fact::rawValueChanged, this,
-                 &MeasurementComplexItem::_changeVariant);
-      this->_variant.setCookedValue(QVariant(0));
-      connect(&this->_variant, &Fact::rawValueChanged, this,
-              &MeasurementComplexItem::_changeVariant);
+        disconnect(&this->_variant, &Fact::rawValueChanged, this,
+                   &MeasurementComplexItem::_changeVariant);
+        this->_variant.setCookedValue(QVariant(0));
+        connect(&this->_variant, &Fact::rawValueChanged, this,
+                &MeasurementComplexItem::_changeVariant);
 
-      if (this->_variantVector.size() > 0) {
-        this->_changeVariantWorker();
+        if (this->_variantVector.size() > 0) {
+          this->_changeVariant();
+        }
       }
     }
   }
 }
 
-void MeasurementComplexItem::_reverseWorker() {
-  if (this->_transects.size() > 0) {
-    auto &t = this->_transects.front();
-    std::reverse(t.begin(), t.end());
+void MeasurementComplexItem::_reverseRoute() {
+  if (ready()) {
+    if (this->_route.size() > 0) {
+      auto &t = this->_route;
+      std::reverse(t.begin(), t.end());
+    }
   }
 }
 
-double MeasurementComplexItem::timeBetweenShots() { return 0; }
-
-QString MeasurementComplexItem::commandDescription() const {
-  return tr("Route");
-}
-
-QString MeasurementComplexItem::commandName() const { return tr("Route"); }
-
-QString MeasurementComplexItem::abbreviation() const { return tr("R"); }
-
-TransectStyleComplexItem::ReadyForSaveState
+ComplexMissionItem::ReadyForSaveState
 MeasurementComplexItem::readyForSaveState() const {
-  if (TransectStyleComplexItem::readyForSaveState() ==
-      TransectStyleComplexItem::ReadyForSaveState::ReadyForSave) {
-    if (this->_state == STATE::IDLE) {
-      return ReadyForSaveState::ReadyForSave;
-    } else {
-      return ReadyForSaveState::NotReadyForSaveData;
-    }
+  if (ready()) {
+    return ReadyForSaveState::ReadyForSave;
   } else {
-    return TransectStyleComplexItem::readyForSaveState();
+    return ReadyForSaveState::NotReadyForSaveData;
   }
 }
 
@@ -583,7 +580,7 @@ bool MeasurementComplexItem::switchToGenerator(int index) {
     return true;
   } else {
     qCDebug(MeasurementComplexItemLog)
-        << "unregisterGenerator(): index (" << index
+        << "switchToGenerator(): index (" << index
         << ") out"
            "of bounds ( "
         << this->_generatorNameList.size() << " ).";
@@ -618,161 +615,120 @@ void MeasurementComplexItem::editingStop() {
     }
     _setAreaData(_areaData);
     _setState(STATE::IDLE);
-  }
-}
-
-void MeasurementComplexItem::_update(void) {
-  auto start = std::chrono::high_resolution_clock::now();
-
-  switch (this->_state) {
-  case STATE::SKIPP:
-    qCDebug(MeasurementComplexItemLog) << "rebuildTransectsPhase1: skipp.";
-    this->_setState(STATE::IDLE);
-    break;
-  case STATE::CHANGE_VARIANT:
-    qCDebug(MeasurementComplexItemLog)
-        << "rebuildTransectsPhase1: variant change.";
-    this->_changeVariantWorker();
-    this->_setState(STATE::IDLE);
-    break;
-  case STATE::REVERT_PATH:
-    qCDebug(MeasurementComplexItemLog) << "rebuildTransectsPhase1: reverse.";
-    this->_reverseWorker();
-    this->_setState(STATE::IDLE);
-    break;
-  case STATE::IDLE:
-  case STATE::ROUTING:
-    this->_setState(STATE::ROUTING);
-    qCDebug(MeasurementComplexItemLog) << "rebuildTransectsPhase1: update.";
-    if (!this->_updateRouteWorker()) {
-      this->_setState(STATE::IDLE);
+    if (_editorData->isValid() && *_editorData != *_areaData) {
+      _updateRoute();
     }
-    break;
   }
-
-  qCDebug(MeasurementComplexItemLog)
-      << "rebuildTransectsPhase1(): "
-      << std::chrono::duration_cast<std::chrono::milliseconds>(
-             std::chrono::high_resolution_clock::now() - start)
-             .count()
-      << " ms";
 }
 
-void MeasurementComplexItem::_recalcCameraShots() { _cameraShots = 0; }
-
-void MeasurementComplexItem::_setTransects(
+void MeasurementComplexItem::_storeRoutingData(
     MeasurementComplexItem::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 (this->_state == STATE::ROUTING) {
+    // 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;
+      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) {
-                idxLast = i;
+                idxFirst = 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});
-            }
+            // 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.
+              for (std::size_t i = idxFirst; i <= idxLast; ++i) {
+                auto &vertex = path[i];
+                QGeoCoordinate c;
+                snake::fromENU(ori, vertex, c);
+                var.append(QVariant::fromValue(c));
+              }
 
+            } else {
+              qCDebug(MeasurementComplexItemLog)
+                  << "_setTransects(): lastTransect.size() == 0";
+            }
           } else {
             qCDebug(MeasurementComplexItemLog)
-                << "_setTransects(): lastTransect.size() == 0";
+                << "_setTransects(): firstTransect.size() == 0";
           }
         } else {
           qCDebug(MeasurementComplexItemLog)
-              << "_setTransects(): firstTransect.size() == 0";
+              << "_setTransects(): transectsInfo.size() <= 1";
         }
       } else {
         qCDebug(MeasurementComplexItemLog)
-            << "_setTransects(): transectsInfo.size() <= 1";
+            << "_setTransects(): solution.size() == 0";
       }
-    } else {
-      qCDebug(MeasurementComplexItemLog)
-          << "_setTransects(): solution.size() == 0";
-    }
 
-    if (var.size() > 0 && var.front().size() > 0) {
-      variantVector.push_back(std::move(var));
+      if (var.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;
-    }
+    // Assign routes if no error occured.
+    if (variantVector.size() > 0) {
+      // Swap first route to _route.
+      this->_variantVector.swap(variantVector);
 
-    // 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();
+      // 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,
-               &MeasurementComplexItem::_changeVariant);
-    this->_variant.setCookedValue(QVariant(0));
-    connect(&this->_variant, &Fact::rawValueChanged, this,
-            &MeasurementComplexItem::_changeVariant);
-    this->_changeVariantWorker();
+      disconnect(&this->_variant, &Fact::rawValueChanged, this,
+                 &MeasurementComplexItem::_changeVariant);
+      this->_variant.setCookedValue(QVariant(0));
+      connect(&this->_variant, &Fact::rawValueChanged, this,
+              &MeasurementComplexItem::_changeVariant);
+      this->_changeVariant();
 
-    this->_setState(STATE::SKIPP);
-    this->_update();
-  } else {
-    qCDebug(MeasurementComplexItemLog)
-        << "_setTransects(): failed, variantVector empty.";
-    this->_setState(STATE::IDLE);
+      this->_setState(STATE::IDLE);
+      emit routeChanged();
+    } else {
+      qCDebug(MeasurementComplexItemLog)
+          << "_setTransects(): failed, variantVector empty.";
+      this->_setState(STATE::IDLE);
+    }
   }
 }
 
diff --git a/src/MeasurementComplexItem/MeasurementComplexItem.h b/src/MeasurementComplexItem/MeasurementComplexItem.h
index 243ee4b3e2e8c58ecf62713b5e5139f7e2327578..c1a7ee42c875d7f3ff8b1cf583581a8c1f019d30 100644
--- a/src/MeasurementComplexItem/MeasurementComplexItem.h
+++ b/src/MeasurementComplexItem/MeasurementComplexItem.h
@@ -24,9 +24,9 @@ class MeasurementComplexItem : public ComplexMissionItem {
   using PtrAreaData = AreaData *;
   using PtrRoutingData = std::shared_ptr<RoutingData>;
   using PtrWorker = RoutingThread *;
-  using Variant = QList<QGeoCoordinate>;
+  using Variant = QVariantList;
 
-  enum class STATE { IDLE, ROUTING, REVERT_PATH, CHANGE_VARIANT, EDITING };
+  enum class STATE { IDLE, ROUTING, EDITING };
 
 public:
   MeasurementComplexItem(PlanMasterController *masterController, bool flyView,
@@ -40,15 +40,17 @@ public:
   Q_PROPERTY(QStringList generatorNameList READ generatorNameList NOTIFY
                  generatorNameListChanged)
   Q_PROPERTY(bool calculating READ calculating NOTIFY calculatingChanged)
+  Q_PROPERTY(bool editing READ editing NOTIFY editingChanged)
+  Q_PROPERTY(bool ready READ ready NOTIFY readyChanged)
   Q_PROPERTY(
       routing::GeneratorBase *generator READ generator NOTIFY generatorChanged)
   Q_PROPERTY(int generatorIndex READ generatorIndex NOTIFY generatorChanged)
   Q_PROPERTY(bool editing READ editing NOTIFY editingChanged)
+  Q_PROPERTY(bool editing READ editing NOTIFY editingChanged)
   Q_PROPERTY(AreaData *areaData READ areaData NOTIFY areaDataChanged)
-  Q_PROPERTY(QVariantList visualTransectPoints READ visualTransectPoints NOTIFY
-                 visualTransectPointsChanged)
+  Q_PROPERTY(QVariantList route READ route NOTIFY routeChanged)
 
-  Q_INVOKABLE void revertPath(void);
+  Q_INVOKABLE void reverseRoute(void);
 
   // Overrides from ComplexMissionItem
   virtual QString patternName(void) const override final;
@@ -104,7 +106,7 @@ public:
   //!
   //! \brief editingStart Starts area data editing.
   //!
-  //! Starts area data editing. Transects will not be updated bewteen a call
+  //! Starts area data editing. Route will not be updated bewteen a call
   //! sequence of editingStart() and editingStop().
   //!
   void editingStart();
@@ -112,18 +114,22 @@ public:
   //! \brief editingStop Stops area editing.
   //!
   //! Stops area editing. Will reset area data to the state before
-  //! editingStart() if it is invalid. Triggers a transect update.
+  //! editingStart() if it is invalid. Triggers a route update.
   //!
   void editingStop();
 
   // Property getters
   const AreaData *areaData() const;
   AreaData *areaData();
+  QVariantList route();
+
   Fact *variant();
   Fact *altitude();
   QStringList variantNames() const;
+
   bool calculating() const;
   bool editing() const;
+  bool ready() const;
   bool followTerrain() const;
 
   static const char *settingsGroup;
@@ -133,23 +139,25 @@ public:
   static const QString name;
 
 signals:
-  void calculatingChanged();
   void variantNamesChanged();
+
   void generatorNameListChanged();
   void generatorChanged();
+
+  void calculatingChanged();
   void editingChanged();
+  void readyChanged();
+
   void areaDataChanged();
+  void routeChanged();
 
 private slots:
-  // Overrides from TransectStyleComplexItem
-  void _update(void);
 
   // Worker functions.
-  void _setTransects(PtrRoutingData pRoute);
+  void _storeRoutingData(PtrRoutingData pRoute);
+  bool _updateRoute();
   void _changeVariant();
-  bool _updateRouteWorker();
-  void _changeVariantWorker();
-  void _reverseWorker();
+  void _reverseRoute();
 
 private:
   bool _setGenerator(PtrGenerator newG);
@@ -157,12 +165,13 @@ private:
   void _setAreaData(PtrAreaData data);
   static bool _calculating(STATE state);
   static bool _editing(STATE state);
+  static bool _ready(STATE state);
 
   // Hirarcical stuff.
   PlanMasterController *_masterController;
   int _sequenceNumber;
   bool _followTerrain;
-  SettingsFact *_altitude;
+  SettingsFact _altitude;
 
   // State.
   STATE _state;
diff --git a/src/MeasurementComplexItem/nemo_interface/SnakeTilesLocal.h b/src/MeasurementComplexItem/nemo_interface/SnakeTilesLocal.h
index 6a7406e1f08fe6c00bf807af3f3956d18dbc251e..8517882e35d8a722dafee1df8ba5bb120a12ce53 100644
--- a/src/MeasurementComplexItem/nemo_interface/SnakeTilesLocal.h
+++ b/src/MeasurementComplexItem/nemo_interface/SnakeTilesLocal.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "RouteMissionItem/geometry/GenericPolygonArray.h"
-#include "RouteMissionItem/nemo_interface/SnakeTileLocal.h"
+#include "MeasurementComplexItem//geometry/GenericPolygonArray.h"
+#include "MeasurementComplexItem//nemo_interface/SnakeTileLocal.h"
 #include <vector>
 typedef GenericPolygonArray<SnakeTileLocal, std::vector> SnakeTilesLocal;