Merge pull request PointCloudLibrary#3094 from SergioRAgostinho/thread

 Remove last traces of Boost Thread

cmake/pcl_find_boost.cmake

@@ -30,10 +30,10 @@ endif()
 
 # Required boost modules
 if(WITH_OPENNI2)
-set(BOOST_REQUIRED_MODULES filesystem thread date_time iostreams chrono system)
+set(BOOST_REQUIRED_MODULES filesystem date_time iostreams chrono system)
 find_package(Boost 1.55.0 REQUIRED COMPONENTS ${BOOST_REQUIRED_MODULES})
 else()
-set(BOOST_REQUIRED_MODULES filesystem thread date_time iostreams system)
+set(BOOST_REQUIRED_MODULES filesystem date_time iostreams system)
 find_package(Boost 1.55.0 REQUIRED COMPONENTS ${BOOST_REQUIRED_MODULES})
 endif()
 

cmake/pcl_pclconfig.cmake

@@ -77,7 +77,7 @@ foreach(_ss ${PCL_SUBSYSTEMS_MODULES})
 endforeach()
 
 #Boost modules
-set(PCLCONFIG_AVAILABLE_BOOST_MODULES "system filesystem thread date_time iostreams")
+set(PCLCONFIG_AVAILABLE_BOOST_MODULES "system filesystem date_time iostreams")
 if(Boost_SERIALIZATION_FOUND)
   set(PCLCONFIG_AVAILABLE_BOOST_MODULES "${PCLCONFIG_AVAILABLE_BOOST_MODULES} serialization")
 endif()

common/include/pcl/common/time_trigger.h

@@ -41,7 +41,6 @@
 #include <pcl/pcl_macros.h>
 #ifndef Q_MOC_RUN
 #include <boost/function.hpp>
-#include <boost/thread.hpp>
 #include <boost/signals2.hpp>
 #endif
 

doc/tutorials/content/building_pcl.rst

@@ -223,12 +223,6 @@ then a sample value is given for reference.
 +----------------------------------+---------------------------------------------------------------+------------------------------------------+
 | Boost_SYSTEM_LIBRARY_RELEASE     | full path to boost_system.[so,lib,a] (release version)        | /usr/local/lib/libboost_system.so        |
 +----------------------------------+---------------------------------------------------------------+------------------------------------------+
-| Boost_THREAD_LIBRARY             | full path to boost_thread.[so,lib,a]                          | /usr/local/lib/libboost_thread.so        |
-+----------------------------------+---------------------------------------------------------------+------------------------------------------+
-| Boost_THREAD_LIBRARY_DEBUG       | full path to boost_thread.[so,lib,a] (debug version)          | /usr/local/lib/libboost_thread-gd.so     |
-+----------------------------------+---------------------------------------------------------------+------------------------------------------+
-| Boost_THREAD_LIBRARY_RELEASE     | full path to boost_thread.[so,lib,a] (release version)        | /usr/local/lib/libboost_thread.so        |
-+----------------------------------+---------------------------------------------------------------+------------------------------------------+
 
 
 * CMinpack

doc/tutorials/content/compiling_pcl_dependencies_windows.rst

@@ -135,7 +135,7 @@ like::
     then fill the **BUILD_PROJECTS** CMake entry (which is set to `ALL` by default) with a semicolon-seperated 
     list of boost modules::
     
-      BUILD_PROJECTS : system;filesystem;date_time;thread;iostreams;tr1;serialization
+      BUILD_PROJECTS : system;filesystem;date_time;iostreams;tr1;serialization
       
     Also, uncheck the **ENABLE_STATIC_RUNTIME** checkbox. Then, click "Configure" again. If you get some 
     errors related to Python, then uncheck **WITH_PYTHON** checkbox, and click "Configure" again. 
@@ -144,7 +144,6 @@ like::
       Reading boost project directories (per BUILD_PROJECTS) 
       
       + date_time
-      + thread
       + serialization
       + system
       + filesystem

gpu/kinfu/tools/kinfu_app.cpp

@@ -831,7 +831,7 @@ struct KinFuApp
   void source_cb1_device(const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper)  
   {        
     {
-      boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
       if (exit_ || !lock)
           return;
 
@@ -849,7 +849,7 @@ struct KinFuApp
   void source_cb2_device(const boost::shared_ptr<openni_wrapper::Image>& image_wrapper, const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper, float)
   {
     {
-      boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
       if (exit_ || !lock)
           return;
 
@@ -876,7 +876,7 @@ struct KinFuApp
    void source_cb1_oni(const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper)  
   {        
     {
-      boost::mutex::scoped_lock lock(data_ready_mutex_);
+      std::lock_guard<std::mutex> lock(data_ready_mutex_);
       if (exit_)
           return;
 
@@ -894,7 +894,7 @@ struct KinFuApp
   void source_cb2_oni(const boost::shared_ptr<openni_wrapper::Image>& image_wrapper, const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper, float)
   {
     {
-      boost::mutex::scoped_lock lock(data_ready_mutex_);
+      std::lock_guard<std::mutex> lock(data_ready_mutex_);
       if (exit_)
           return;
 
@@ -921,7 +921,7 @@ struct KinFuApp
   source_cb3 (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr & DC3)
   {
     {
-      boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
       if (exit_ || !lock)
         return;
       int width  = DC3->width;
@@ -981,7 +981,7 @@ struct KinFuApp
     boost::signals2::connection c = pcd_source_? capture_.registerCallback (func3) : need_colors ? capture_.registerCallback (func1) : capture_.registerCallback (func2);
 
     {
-      boost::unique_lock<boost::mutex> lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock(data_ready_mutex_);
 
       if (!triggered_capture)
           capture_.start (); // Start stream
@@ -1097,8 +1097,8 @@ struct KinFuApp
 
   Evaluation::Ptr evaluation_ptr_;
 
-  boost::mutex data_ready_mutex_;
-  boost::condition_variable data_ready_cond_;
+  std::mutex data_ready_mutex_;
+  std::condition_variable data_ready_cond_;
 
   std::vector<KinfuTracker::PixelRGB> source_image_data_;
   std::vector<unsigned short> source_depth_data_;

gpu/kinfu_large_scale/tools/kinfuLS_app.cpp

@@ -890,7 +890,7 @@ struct KinFuLSApp
   void source_cb1(const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper)  
   {        
     {
-      boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
       if (exit_ || !lock)
         return;
 
@@ -908,7 +908,7 @@ struct KinFuLSApp
   void source_cb2(const boost::shared_ptr<openni_wrapper::Image>& image_wrapper, const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper, float)
   {
     {
-      boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
 
       if (exit_ || !lock)
       {
@@ -939,7 +939,7 @@ struct KinFuLSApp
   {
     {                             
       //std::cout << "Giving colors1\n";
-      boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
       //std::cout << lock << std::endl; //causes compile errors 
       if (exit_ || !lock)
         return;
@@ -994,7 +994,7 @@ struct KinFuLSApp
     boost::signals2::connection c = pcd_source_? capture_.registerCallback (func3) : need_colors ? capture_.registerCallback (func1) : capture_.registerCallback (func2);
 
     {
-      boost::unique_lock<boost::mutex> lock(data_ready_mutex_);
+      std::unique_lock<std::mutex> lock(data_ready_mutex_);
 
       if (!triggered_capture) 
         capture_.start ();
@@ -1109,8 +1109,8 @@ struct KinFuLSApp
 
   Evaluation::Ptr evaluation_ptr_;
 
-  boost::mutex data_ready_mutex_;
-  boost::condition_variable data_ready_cond_;
+  std::mutex data_ready_mutex_;
+  std::condition_variable data_ready_cond_;
 
   std::vector<pcl::gpu::kinfuLS::PixelRGB> source_image_data_;
   std::vector<unsigned short> source_depth_data_;

gpu/kinfu_large_scale/tools/record_maps_rgb.cpp

@@ -32,22 +32,23 @@
  *  Author: Raphael Favier, Technical University Eindhoven, (r.mysurname < aT > tue.nl)
  */
 
-#include <csignal>
-#include <ctime>
-#include <thread>
-
 #include <pcl/point_cloud.h>
 #include <pcl/point_types.h>
 #include <pcl/io/openni_grabber.h>
-#include <boost/thread/condition.hpp>
-#include <boost/circular_buffer.hpp>
 #include <pcl/io/pcd_io.h>
 #include <pcl/common/time.h> //fps calculations
-
 #include <pcl/gpu/containers/kernel_containers.h>
 #include <pcl/io/png_io.h>
 #include <pcl/console/print.h>
 
+#include <boost/circular_buffer.hpp>
+
+#include <condition_variable>
+#include <csignal>
+#include <ctime>
+#include <mutex>
+#include <thread>
+
 using namespace std::chrono_literals;
 
 #define FPS_CALC(_WHAT_) \
@@ -66,7 +67,7 @@ do \
 }while(false)
 
 bool is_done = false;
-boost::mutex io_mutex;
+std::mutex io_mutex;
 
 const int BUFFER_SIZE = 1000;
 static int counter = 1;
@@ -98,21 +99,21 @@ class MapsBuffer
     inline bool 
     isFull ()
     {
-      boost::mutex::scoped_lock buff_lock (bmutex_);
+      std::lock_guard<std::mutex> buff_lock (bmutex_);
       return (buffer_.full ());
     }
 
     inline bool
     isEmpty ()
     {
-      boost::mutex::scoped_lock buff_lock (bmutex_);
+      std::lock_guard<std::mutex> buff_lock (bmutex_);
       return (buffer_.empty ());
     }
 
     inline int 
     getSize ()
     {
-      boost::mutex::scoped_lock buff_lock (bmutex_);
+      std::lock_guard<std::mutex> buff_lock (bmutex_);
       return (int (buffer_.size ()));
     }
 
@@ -125,16 +126,16 @@ class MapsBuffer
     inline void 
     setCapacity (int buff_size)
     {
-      boost::mutex::scoped_lock buff_lock (bmutex_);
+      std::lock_guard<std::mutex> buff_lock (bmutex_);
       buffer_.set_capacity (buff_size);
     }
 
   private:
     MapsBuffer (const MapsBuffer&) = delete; // Disabled copy constructor
     MapsBuffer& operator =(const MapsBuffer&) = delete; // Disabled assignment operator
 
-    boost::mutex bmutex_;
-    boost::condition_variable buff_empty_;
+    std::mutex bmutex_;
+    std::condition_variable buff_empty_;
     boost::circular_buffer<boost::shared_ptr<const MapsRgb> > buffer_;                                     
 
 };
@@ -146,7 +147,7 @@ MapsBuffer::pushBack(boost::shared_ptr<const MapsRgb> maps_rgb )
 {
   bool retVal = false;
   {
-    boost::mutex::scoped_lock buff_lock (bmutex_);
+    std::lock_guard<std::mutex> buff_lock (bmutex_);
     if (!buffer_.full ())
       retVal = true;
     buffer_.push_back (maps_rgb);
@@ -162,13 +163,13 @@ MapsBuffer::getFront(bool print)
 {
   boost::shared_ptr< const MapsBuffer::MapsRgb > depth_rgb;
   {
-    boost::mutex::scoped_lock buff_lock (bmutex_);
+    std::lock_guard<std::mutex> buff_lock (bmutex_);
     while (buffer_.empty ())
     {
       if (is_done)
         break;
       {
-        boost::mutex::scoped_lock io_lock (io_mutex);
+        std::lock_guard<std::mutex> io_lock (io_mutex);
               //std::cout << "No data in buffer_ yet or buffer is empty." << std::endl;
       }
       buff_empty_.wait (buff_lock);
@@ -242,7 +243,7 @@ grabberMapsCallBack(const boost::shared_ptr<openni_wrapper::Image>& image_wrappe
   if (!buff.pushBack (ptr))
   {
     {
-      boost::mutex::scoped_lock io_lock(io_mutex);
+      std::lock_guard<std::mutex> io_lock(io_mutex);
       PCL_WARN ("Warning! Buffer was full, overwriting data\n");
     }
   }
@@ -287,7 +288,7 @@ receiveAndProcess ()
   }
 
   {
-    boost::mutex::scoped_lock io_lock (io_mutex);
+    std::lock_guard<std::mutex> io_lock (io_mutex);
     PCL_INFO ("Writing remaining %d maps in the buffer to disk...\n", buff.getSize ());
   }
   while (!buff.isEmpty ())
@@ -300,7 +301,7 @@ receiveAndProcess ()
 void 
 ctrlC (int)
 {
-  boost::mutex::scoped_lock io_lock (io_mutex);
+  std::lock_guard<std::mutex> io_lock (io_mutex);
   std::cout << std::endl;
   PCL_WARN ("Ctrl-C detected, exit condition set to true\n");
   is_done = true;
@@ -331,7 +332,7 @@ main (int argc, char** argv)
   signal (SIGINT, ctrlC);
   producer.join ();
   {
-    boost::mutex::scoped_lock io_lock (io_mutex);
+    std::lock_guard<std::mutex> io_lock (io_mutex);
     PCL_WARN ("Producer done\n");
   }
   consumer.join ();

gpu/people/tools/people_app.cpp

@@ -214,7 +214,7 @@ class PeoplePCDApp
     void source_cb1(const boost::shared_ptr<const PointCloud<PointXYZRGBA> >& cloud)
     {
       {          
-        boost::mutex::scoped_lock lock(data_ready_mutex_);
+        std::lock_guard<std::mutex> lock(data_ready_mutex_);
         if (exit_)
           return;
 
@@ -226,7 +226,7 @@ class PeoplePCDApp
     void source_cb2(const boost::shared_ptr<openni_wrapper::Image>& image_wrapper, const boost::shared_ptr<openni_wrapper::DepthImage>& depth_wrapper, float)
     {
       {                    
-        boost::mutex::scoped_try_lock lock(data_ready_mutex_);
+        std::unique_lock<std::mutex> lock (data_ready_mutex_, std::try_to_lock);
 
         if (exit_ || !lock)
           return;
@@ -286,7 +286,7 @@ class PeoplePCDApp
       boost::signals2::connection c = cloud_cb_ ? capture_.registerCallback (func1) : capture_.registerCallback (func2);
 
       {
-        boost::unique_lock<boost::mutex> lock(data_ready_mutex_);
+        std::unique_lock<std::mutex> lock(data_ready_mutex_);
 
         try 
         { 
@@ -319,8 +319,8 @@ class PeoplePCDApp
       c.disconnect();
     }
 
-    boost::mutex data_ready_mutex_;
-    boost::condition_variable data_ready_cond_;
+    std::mutex data_ready_mutex_;
+    std::condition_variable data_ready_cond_;
 
     pcl::Grabber& capture_;