point and area picking improvement for cloud names (#5476)

* point and area picking improvement for cloud names

* Change to index_t for remaining int indexes / point counts.

* Added simple area callback to pcd_viewer.

* Comment unused variable.

* Apply clang-tidy suggestions.

* Fix more indices types.

* Removed nb_points.

Replaced static_cast<pcl::index_t>(-1) with pcl::UNAVAILABLE.

Co-authored-by: janekT <j.trochta@gmail.com>

Author: larshg

tools/pcd_viewer.cpp

@@ -136,6 +136,8 @@ printHelp (int, char **argv)
   print_info ("\n");
   print_info ("                     -use_point_picking       = enable the usage of picking points on screen (default "); print_value ("disabled"); print_info (")\n");
   print_info ("\n");
+  print_info ("                     -use_area_picking       = enable the usage of area picking points on screen (default "); print_value("disabled"); print_info(")\n");
+  print_info ("\n");
   print_info ("                     -optimal_label_colors    = maps existing labels to the optimal sequential glasbey colors, label_ids will not be mapped to fixed colors (default "); print_value ("disabled"); print_info (")\n");
   print_info ("\n");
   print_info ("                     -edl                     = Enable Eye-Dome Lighting rendering, to improve depth perception. (default: "); print_value ("disabled"); print_info (")\n");
@@ -152,6 +154,18 @@ pcl::search::KdTree<pcl::PointXYZ> search;
 pcl::PCLPointCloud2::Ptr cloud;
 pcl::PointCloud<pcl::PointXYZ>::Ptr xyzcloud;
 
+void
+area_callback(const pcl::visualization::AreaPickingEvent& event, void* /*cookie*/)
+{
+  const auto names = event.getCloudNames();
+
+  for (const std::string& name : names) {
+    const pcl::Indices indices = event.getPointsIndices(name);
+
+    PCL_INFO("Picked %d points from %s \n", indices.size(), name.c_str());
+  }
+}
+
 void
 pp_callback (const pcl::visualization::PointPickingEvent& event, void* cookie)
 {
@@ -284,6 +298,10 @@ main (int argc, char** argv)
   if (use_pp) 
     print_highlight ("Point picking enabled.\n");
 
+  bool use_ap = pcl::console::find_switch(argc, argv, "-use_area_picking");
+  if (use_ap)
+    print_highlight("Area picking enabled. \n");
+
   bool use_optimal_l_colors = pcl::console::find_switch (argc, argv, "-optimal_label_colors");
   if (use_optimal_l_colors)
     print_highlight ("Optimal glasbey colors are being assigned to existing labels.\nNote: No static mapping between label ids and colors\n");
@@ -489,6 +507,9 @@ main (int argc, char** argv)
       if (use_pp)   // Only enable the point picking callback if the command line parameter is enabled
         p->registerPointPickingCallback (&pp_callback, static_cast<void*> (&cloud));
 
+      if (use_ap)
+        p->registerAreaPickingCallback(&area_callback);
+
       if (useEDLRendering)
         p->enableEDLRendering();
 

visualization/include/pcl/visualization/area_picking_event.h

@@ -40,6 +40,8 @@
 
 #include <pcl/pcl_macros.h>
 
+#include <map>
+
 namespace pcl
 {
   namespace visualization
@@ -48,27 +50,58 @@ namespace pcl
     class PCL_EXPORTS AreaPickingEvent
     {
       public:
-        AreaPickingEvent (int nb_points, const pcl::Indices& indices)
-          : nb_points_ (nb_points)
-          , indices_ (indices)
+        AreaPickingEvent (std::map<std::string, pcl::Indices> cloud_indices)
+        : cloud_indices_ (std::move(cloud_indices))
         {}
 
-        /** \brief For situations where a whole are is selected, return the points indices.
+        PCL_DEPRECATED(1,16,"This constructor is deprecated!")
+        AreaPickingEvent(int /*nb_points*/, const pcl::Indices& indices)
+          : AreaPickingEvent ({{"",indices}}) {}
+
+        /** \brief For situations where a whole area is selected, return the points indices.
           * \param[out] indices indices of the points under the area selected by user.
           * \return true, if the area selected by the user contains points, false otherwise
           */
         inline bool
         getPointsIndices (pcl::Indices& indices) const
         {
-          if (nb_points_ <= 0)
+          if (cloud_indices_.empty())
             return (false);
-          indices = indices_;
+
+          for (const auto& i : cloud_indices_)
+            indices.insert(indices.cend (), i.second.cbegin (), i.second.cend ());
+
           return (true);
         }
+        /** \brief For situations where a whole area is selected, return the names
+          * of the selected point clouds.
+          * \return The names of selected point clouds
+          */
+        inline std::vector<std::string>
+        getCloudNames () const
+        {
+          std::vector<std::string> names;
+          for (const auto& i : cloud_indices_)
+            names.push_back (i.first);
+          return names;
+        }
+        /** \brief For situations where a whole area is selected, return the points indices
+          * for a given point cloud
+          * \param[in] name of selected clouds.
+          * \return The indices for the selected cloud.
+          */
+        inline Indices
+        getPointsIndices (const std::string& name) const
+        {
+          const auto cloud = cloud_indices_.find (name);
+          if(cloud == cloud_indices_.cend ())
+            return Indices ();
+
+          return cloud->second;
+        }
 
       private:
-        int nb_points_;
-        pcl::Indices indices_;
+        std::map<std::string, pcl::Indices> cloud_indices_;
     };
   } //namespace visualization
 } //namespace pcl

visualization/include/pcl/visualization/point_picking_event.h

@@ -38,10 +38,18 @@
 
 #pragma once
 
+#include <pcl/pcl_base.h>
 #include <pcl/pcl_macros.h>
 #include <pcl/types.h> // for pcl::Indices
+#include <pcl/visualization/common/actor_map.h>
 
 #include <vtkCommand.h>
+#include <vtkActor.h>
+
+#include <map>
+#include <vector>
+
+
 class vtkRenderWindowInteractor;
 
 namespace pcl
@@ -55,38 +63,39 @@ namespace pcl
         { 
           return (new PointPickingCallback); 
         }
-
-        PointPickingCallback () : x_ (0), y_ (0), z_ (0), idx_ (-1), pick_first_ (false) {}
 
         /** \brief Empty destructor */
         ~PointPickingCallback () override = default;
 
         void
         Execute (vtkObject *caller, unsigned long eventid, void*) override;
 
-        int
+        pcl::index_t
         performSinglePick (vtkRenderWindowInteractor *iren);
 
-        int
+        pcl::index_t
         performSinglePick (vtkRenderWindowInteractor *iren, float &x, float &y, float &z);
 
-        int
-        performAreaPick (vtkRenderWindowInteractor *iren, pcl::Indices &indices) const;
+        pcl::index_t
+        performAreaPick (vtkRenderWindowInteractor *iren,
+                         CloudActorMapPtr cam_ptr,
+                         std::map<std::string, pcl::Indices>& cloud_indices) const;
+
 
       private:
-        float x_, y_, z_;
-        int idx_;
-        bool pick_first_;
+        float x_{0}, y_{0}, z_{0};
+        pcl::index_t idx_{pcl::UNAVAILABLE};
+        bool pick_first_{false};
+        const vtkActor* actor_{nullptr};
      };
 
     /** /brief Class representing 3D point picking events. */
     class PCL_EXPORTS PointPickingEvent
     {
       public:
-        PointPickingEvent (int idx) : idx_ (idx), idx2_ (-1), x_ (), y_ (), z_ (), x2_ (), y2_ (), z2_ () {}
-        PointPickingEvent (int idx, float x, float y, float z) : idx_ (idx), idx2_ (-1), x_ (x), y_ (y), z_ (z), x2_ (), y2_ (), z2_ () {}
-
-        PointPickingEvent (int idx1, int idx2, float x1, float y1, float z1, float x2, float y2, float z2) :
+        PointPickingEvent (pcl::index_t idx) : PointPickingEvent ( idx, -1,-1, -1) {}
+        PointPickingEvent (pcl::index_t idx, float x, float y, float z, const std::string& name = "") : idx_ (idx), idx2_ (-1), x_ (x), y_ (y), z_ (z), x2_ (), y2_ (), z2_ (), name_ (name) {}
+        PointPickingEvent (pcl::index_t idx1, pcl::index_t idx2, float x1, float y1, float z1, float x2, float y2, float z2) :
           idx_ (idx1), idx2_ (idx2), x_ (x1), y_ (y1), z_ (z1), x2_ (x2), y2_ (y2), z2_ (z2) 
         {}
 
@@ -97,7 +106,7 @@ namespace pcl
           * cloud for the correct index. An example of how to do this can be found in the pp_callback function in
           * visualization/tools/pcd_viewer.cpp
           */
-        inline int
+        inline pcl::index_t
         getPointIndex () const
         {
           return (idx_);
@@ -126,7 +135,7 @@ namespace pcl
         inline bool
         getPoints (float &x1, float &y1, float &z1, float &x2, float &y2, float &z2) const
         {
-          if (idx2_ == -1)
+          if (idx2_ == pcl::UNAVAILABLE)
             return (false);
           x1 = x_; y1 = y_; z1 = z_;
           x2 = x2_; y2 = y2_; z2 = z2_;
@@ -144,20 +153,27 @@ namespace pcl
           * visualization/tools/pcd_viewer.cpp
           */
         inline bool
-        getPointIndices (int &index_1, int &index_2) const
+        getPointIndices(pcl::index_t& index_1, pcl::index_t& index_2) const
         {
-          if (idx2_ == -1)
+          if (idx2_ == pcl::UNAVAILABLE)
             return (false);
           index_1 = idx_;
           index_2 = idx2_;
           return (true);
         }
 
+        /** \brief Get name of selected cloud.
+          * \return name of the cloud selected by the user
+          */
+        inline const std::string&
+        getCloudName () const { return name_; }
+
       private:
-        int idx_, idx2_;
+        pcl::index_t idx_, idx2_;
 
         float x_, y_, z_;
         float x2_, y2_, z2_;
+        std::string name_;
     };
   } //namespace visualization
 } //namespace pcl