Landmarks really observed

doc/rel_notes/0.9.0.txt

@@ -87,6 +87,9 @@ Visualization Application
 
  * The GUI now accepts a list of files to be opened on the command line.
 
+ * Added options to the World and Camera view to visualize the landmarks seen
+   by the current camera. Those landmarks can also be colored and thresholded.
+
  * Added a depth map view and a depth map visualisation in the world view. The
    depth maps can be thresholded directly in the world view, and the depth map
    view offers several visualisation modes such as depths, uniqueness ratios or

gui/CMakeLists.txt

@@ -42,6 +42,7 @@ set(gui_ui
   FeatureOptions.ui
   ImageOptions.ui
   PointOptions.ui
+  VisibleLandmarksOptions.ui
 )
 
 set(gui_resources
@@ -67,6 +68,7 @@ set(gui_moc_headers
   MatchMatrixWindow.h
   PointOptions.h
   WorldView.h
+  VisibleLandmarksOptions.h
   tools/AbstractTool.h
   tools/BundleAdjustTool.h
   tools/CanonicalTransformTool.h
@@ -93,6 +95,7 @@ set(gui_sources
   PointOptions.cxx
   Project.cxx
   WorldView.cxx
+  VisibleLandmarksOptions.cxx
   main.cxx
   vtkMaptkCamera.cxx
   vtkMaptkCameraRepresentation.cxx

gui/CameraView.cxx

@@ -202,6 +202,8 @@ class CameraViewPrivate
 
   LandmarkCloud landmarks;
   SegmentCloud residuals;
+  LandmarkCloud visibleLandmarks;
+  LandmarkCloud nonVisibleLandmarks;
 
   QHash<kwiver::vital::landmark_id_t, LandmarkData> landmarkData;
 
@@ -248,7 +250,6 @@ CameraViewPrivate::PointCloud::PointCloud()
 void CameraViewPrivate::PointCloud::addPoint(double x, double y, double z)
 {
   auto const vid = this->points->InsertNextPoint(x, y, z);
-
   this->verts->InsertNextCell(1);
   this->verts->InsertCellPoint(vid);
 
@@ -375,6 +376,8 @@ void CameraViewPrivate::setTransforms(int imageHeight)
   this->featureRep->GetTrailsActor()->SetUserMatrix(xf.GetPointer());
   this->landmarks.actor->SetUserMatrix(xf.GetPointer());
   this->residuals.actor->SetUserMatrix(xf.GetPointer());
+  this->visibleLandmarks.actor->SetUserMatrix(xf.GetPointer());
+  this->nonVisibleLandmarks.actor->SetUserMatrix(xf.GetPointer());
 }
 
 //-----------------------------------------------------------------------------
@@ -428,6 +431,11 @@ CameraView::CameraView(QWidget* parent, Qt::WindowFlags flags)
   d->landmarkOptions->setDefaultColor(Qt::magenta);
   d->landmarkOptions->addActor(d->landmarks.actor.GetPointer());
   d->landmarkOptions->addMapper(d->landmarks.mapper.GetPointer());
+  d->landmarkOptions->addVisibleLandmarksActor(d->visibleLandmarks.actor.GetPointer());
+  d->landmarkOptions->addNonVisibleLandmarksActor(d->nonVisibleLandmarks.actor.GetPointer());
+
+  d->visibleLandmarks.actor->SetVisibility(d->landmarkOptions->isVisibleLandmarksChecked());
+  d->nonVisibleLandmarks.actor->SetVisibility(false);
 
   d->setPopup(d->UI.actionShowLandmarks, d->landmarkOptions);
 
@@ -465,6 +473,9 @@ CameraView::CameraView(QWidget* parent, Qt::WindowFlags flags)
   connect(d->UI.actionShowResiduals, SIGNAL(toggled(bool)),
           this, SLOT(setResidualsVisible(bool)));
 
+  connect(d->landmarkOptions, SIGNAL(visibleLandmarksDisplayChanged(bool)),
+          this, SLOT(switchToVisibleLandmarksMode(bool)));
+
   // Set up ortho view
   d->renderer->GetActiveCamera()->ParallelProjectionOn();
   d->renderer->GetActiveCamera()->SetClippingRange(1.0, 3.0);
@@ -484,6 +495,8 @@ CameraView::CameraView(QWidget* parent, Qt::WindowFlags flags)
   d->renderer->AddActor(d->featureRep->GetTrailsActor());
   d->renderer->AddActor(d->landmarks.actor.GetPointer());
   d->renderer->AddActor(d->residuals.actor.GetPointer());
+  d->renderer->AddActor(d->visibleLandmarks.actor.GetPointer());
+  d->renderer->AddActor(d->nonVisibleLandmarks.actor.GetPointer());
 
   d->renderer->AddViewProp(d->imageActor.GetPointer());
   d->imageActor->SetPosition(0.0, 0.0, -0.5);
@@ -621,6 +634,25 @@ void CameraView::addLandmark(
   d->UI.renderWidget->update();
 }
 
+//-----------------------------------------------------------------------------
+void CameraView::addVisibleLandmark(
+    kwiver::vital::landmark_id_t id, double x, double y)
+{
+  QTE_D();
+
+  d->visibleLandmarks.addPoint(x, y, 1.0, d->landmarkData.value(id));
+  d->UI.renderWidget->update();
+}
+
+//-----------------------------------------------------------------------------
+void CameraView::addNonVisibleLandmark(kwiver::vital::landmark_id_t id, double x, double y)
+{
+  QTE_D();
+
+  d->nonVisibleLandmarks.addPoint(x, y, 1.0, d->landmarkData.value(id));
+  d->UI.renderWidget->update();
+}
+
 //-----------------------------------------------------------------------------
 void CameraView::addResidual(
   kwiver::vital::track_id_t id, double x1, double y1, double x2, double y2)
@@ -648,6 +680,30 @@ void CameraView::clearResiduals()
   d->residuals.clear();
 }
 
+//-----------------------------------------------------------------------------
+void CameraView::setVisibleLandmarksVisibleOnly(bool state)
+{
+  QTE_D();
+
+  d->landmarks.actor->SetVisibility(!state);
+
+  d->UI.renderWidget->update();
+}
+
+//-----------------------------------------------------------------------------
+void CameraView::clearVisibleLandmarks()
+{
+  QTE_D();
+  d->visibleLandmarks.clear();
+}
+
+//-----------------------------------------------------------------------------
+void CameraView::clearNonVisibleLandmarks()
+{
+  QTE_D();
+  d->nonVisibleLandmarks.clear();
+}
+
 //-----------------------------------------------------------------------------
 void CameraView::setImageVisible(bool state)
 {
@@ -662,7 +718,26 @@ void CameraView::setLandmarksVisible(bool state)
 {
   QTE_D();
 
-  d->landmarks.actor->SetVisibility(state);
+  if(d->landmarkOptions->isVisibleLandmarksChecked())
+  {
+    d->visibleLandmarks.actor->SetVisibility(state);
+    d->nonVisibleLandmarks.actor->SetVisibility(state && !d->landmarkOptions->
+                                              isVisibleLandmarksOnlyChecked());
+  }
+  else
+  {
+    d->landmarks.actor->SetVisibility(state);
+  }
+
+  d->UI.renderWidget->update();
+}
+
+//-----------------------------------------------------------------------------
+void CameraView::setVisibleLandmarksVisible(bool state)
+{
+  QTE_D();
+
+  d->visibleLandmarks.actor->SetVisibility(state);
   d->UI.renderWidget->update();
 }
 
@@ -718,4 +793,17 @@ void CameraView::updateFeatures()
   }
 }
 
+//-----------------------------------------------------------------------------
+void CameraView::switchToVisibleLandmarksMode(bool state)
+{
+  QTE_D();
+
+  d->landmarks.actor->SetVisibility(!state);
+  d->visibleLandmarks.actor->SetVisibility(state);
+  d->nonVisibleLandmarks.actor->SetVisibility(state && !d->landmarkOptions->
+                                            isVisibleLandmarksOnlyChecked());
+
+  d->UI.renderWidget->update();
+}
+
 //END CameraView

gui/CameraView.h

@@ -67,23 +67,35 @@ public slots:
   void setActiveFrame(unsigned);
 
   void addLandmark(kwiver::vital::landmark_id_t id, double x, double y);
+
+  void addVisibleLandmark(kwiver::vital::landmark_id_t id, double x, double y);
+
+  void addNonVisibleLandmark(kwiver::vital::landmark_id_t id, double x, double y);
+
   void addResidual(kwiver::vital::track_id_t id,
                    double x1, double y1,
                    double x2, double y2);
 
   void clearLandmarks();
+  void clearVisibleLandmarks();
+  void clearNonVisibleLandmarks();
   void clearResiduals();
 
+  void setVisibleLandmarksVisibleOnly(bool);
+
   void resetView();
   void resetViewToFullExtents();
 
 protected slots:
   void setImageVisible(bool);
   void setLandmarksVisible(bool);
+  void setVisibleLandmarksVisible(bool);
   void setResidualsVisible(bool);
 
   void updateFeatures();
 
+  void switchToVisibleLandmarksMode(bool);
+
 private:
   QTE_DECLARE_PRIVATE_RPTR(CameraView)
   QTE_DECLARE_PRIVATE(CameraView)

gui/CameraView.ui

@@ -6,15 +6,24 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>595</width>
-    <height>300</height>
+    <width>654</width>
+    <height>302</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
-   <property name="margin">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>

gui/MainWindow.cxx

@@ -223,6 +223,9 @@ class MainWindowPrivate
 
     QString imagePath; // Full path to camera image data
     QString depthMapPath; // Full path to depth map data
+    kwiver::vital::landmark_map::map_landmark_t *visibleLandmarks;
+    kwiver::vital::landmark_map::map_landmark_t *nonVisibleLandmarks;
+    bool areVisibleLandmarksLoaded = false;
   };
 
   // Methods
@@ -340,6 +343,10 @@ void MainWindowPrivate::addFrame(
 
   cd.imagePath = imagePath;
 
+
+  cd.visibleLandmarks = new kwiver::vital::landmark_map::map_landmark_t();
+  cd.nonVisibleLandmarks = new kwiver::vital::landmark_map::map_landmark_t();
+
   if (camera)
   {
     this->orphanImages.clear();
@@ -423,8 +430,42 @@ void MainWindowPrivate::setActiveCamera(int id)
 {
   this->activeCameraIndex = id;
   this->UI.worldView->setActiveCamera(this->cameras[id].camera);
+
+  //Load visible landmarks for the active camera once
+  if(!this->cameras[id].areVisibleLandmarksLoaded)
+  {
+
+    *this->cameras[id].nonVisibleLandmarks = landmarks->landmarks();
+
+    auto const& tracks = this->tracks->tracks();
+    foreach (auto const& track, tracks)
+    {
+      if (track->find(id) != track->end())
+      {
+        auto const& landmarkId = track->id();
+        auto const& landmark = this->landmarks->landmarks()[landmarkId];
+
+        if (landmark)
+        {
+          this->cameras[id].visibleLandmarks->insert(
+                std::make_pair(landmarkId, landmark));
+          this->cameras[id].nonVisibleLandmarks->erase(landmarkId);
+        }
+      }
+    }
+
+    this->cameras[id].areVisibleLandmarksLoaded = true;
+  }
+
   this->updateCameraView();
 
+  this->UI.worldView->setVisibleLandmarks(kwiver::vital::simple_landmark_map(
+                                            *this->cameras[id].visibleLandmarks));
+
+
+  this->UI.worldView->setNonVisibleLandmarks(kwiver::vital::simple_landmark_map(
+                                            *this->cameras[id].nonVisibleLandmarks));
+
   auto& cd = this->cameras[id];
   if (!cd.depthMapPath.isEmpty())
   {
@@ -502,6 +543,25 @@ void MainWindowPrivate::updateCameraView()
       }
     }
   }
+
+  // Show landmarks visible by the current camera
+  this->UI.cameraView->clearVisibleLandmarks();
+  foreach (auto const& landmark, *this->cameras[this->activeCameraIndex].visibleLandmarks)
+  {
+    auto coord = landmark.second->loc();
+    double pp[2];
+    this->cameras[this->activeCameraIndex].camera->ProjectPoint(coord,pp);
+    this->UI.cameraView->addVisibleLandmark(landmark.first,pp[0],pp[1]);
+  }
+
+  this->UI.cameraView->clearNonVisibleLandmarks();
+  foreach (auto const& landmark, *this->cameras[this->activeCameraIndex].nonVisibleLandmarks)
+  {
+    auto coord = landmark.second->loc();
+    double pp[2];
+    this->cameras[this->activeCameraIndex].camera->ProjectPoint(coord,pp);
+    this->UI.cameraView->addNonVisibleLandmark(landmark.first,pp[0],pp[1]);
+  }
 }
 
 //-----------------------------------------------------------------------------