replace throw () by noexcept

filters/include/pcl/filters/box_clipper3D.h

@@ -89,7 +89,7 @@ namespace pcl
       /**
         * \brief virtual destructor
         */
-      ~BoxClipper3D () throw ();
+      ~BoxClipper3D () noexcept;
 
       bool
       clipPoint3D (const PointT& point) const override;

filters/include/pcl/filters/clipper3D.h

@@ -59,7 +59,7 @@ namespace pcl
       /**
         * \brief virtual destructor. Never throws an exception.
         */
-      virtual ~Clipper3D () throw () {}
+      virtual ~Clipper3D () noexcept {}
 
       /**
         * \brief interface to clip a single point

filters/include/pcl/filters/impl/box_clipper3D.hpp

@@ -53,7 +53,7 @@ pcl::BoxClipper3D<PointT>::BoxClipper3D (const Eigen::Vector3f& rodrigues, const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 template<typename PointT>
-pcl::BoxClipper3D<PointT>::~BoxClipper3D () throw ()
+pcl::BoxClipper3D<PointT>::~BoxClipper3D () noexcept
 {
 }
 

filters/include/pcl/filters/impl/plane_clipper3D.hpp

@@ -44,7 +44,7 @@ pcl::PlaneClipper3D<PointT>::PlaneClipper3D (const Eigen::Vector4f& plane_params
 }
 
 template<typename PointT>
-pcl::PlaneClipper3D<PointT>::~PlaneClipper3D () throw ()
+pcl::PlaneClipper3D<PointT>::~PlaneClipper3D () noexcept
 {
 }
 

filters/include/pcl/filters/plane_clipper3D.h

@@ -61,7 +61,7 @@ namespace pcl
        */
       PlaneClipper3D (const Eigen::Vector4f& plane_params);
 
-      virtual ~PlaneClipper3D () throw ();
+      virtual ~PlaneClipper3D () noexcept;
 
       /**
         * \brief Set new plane parameters

io/include/pcl/io/davidsdk_grabber.h

@@ -88,7 +88,7 @@ namespace pcl
 
       /** @brief Destructor inherited from the Grabber interface. It never throws. */
       virtual
-      ~DavidSDKGrabber () throw ();
+      ~DavidSDKGrabber () noexcept;
 
       /** @brief [Connect](http://docs.david-3d.com/sdk/en/classdavid_1_1_client_json_rpc.html#a4b948e57a2e5e7f9cdcf1171c500aa24) client
        * @param[in] address

io/include/pcl/io/depth_sense/depth_sense_grabber_impl.h

@@ -105,7 +105,7 @@ namespace pcl
 
         DepthSenseGrabberImpl (DepthSenseGrabber* parent, const std::string& device_id);
 
-        ~DepthSenseGrabberImpl () throw ();
+        ~DepthSenseGrabberImpl () noexcept;
 
         void
         start ();

io/include/pcl/io/depth_sense_grabber.h

@@ -92,7 +92,7 @@ namespace pcl
       DepthSenseGrabber (const std::string& device_id = "");
 
       virtual
-      ~DepthSenseGrabber () throw ();
+      ~DepthSenseGrabber () noexcept;
 
       virtual void
       start ();

io/include/pcl/io/dinast_grabber.h

@@ -68,7 +68,7 @@ namespace pcl
       DinastGrabber (const int device_position=1);
 
       /** \brief Destructor. It never throws. */
-      ~DinastGrabber () throw ();
+      ~DinastGrabber () noexcept;
 
       /** \brief Check if the grabber is running
         * \return true if grabber is running / streaming. False otherwise.

io/include/pcl/io/ensenso_grabber.h

@@ -88,7 +88,7 @@ namespace pcl
 
       /** @brief Destructor inherited from the Grabber interface. It never throws. */
       virtual
-      ~EnsensoGrabber () throw ();
+      ~EnsensoGrabber () noexcept;
 
       /** @brief Searches for available devices
        * @returns The number of Ensenso devices connected */

io/include/pcl/io/hdl_grabber.h

@@ -117,7 +117,7 @@ namespace pcl
 
       /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
       
-      ~HDLGrabber () throw ();
+      ~HDLGrabber () noexcept;
 
       /** \brief Starts processing the Velodyne packets, either from the network or PCAP file. */
       void

io/include/pcl/io/image_grabber.h

@@ -94,7 +94,7 @@ namespace pcl
     }
 
     /** \brief Virtual destructor. */
-    ~ImageGrabberBase () throw ();
+    ~ImageGrabberBase () noexcept;
 
     /** \brief Starts playing the list of PCD files if frames_per_second is > 0. Otherwise it works as a trigger: publishes only the next PCD file in the list. */
     void 
@@ -235,7 +235,7 @@ namespace pcl
                   bool repeat = false);
       
     /** \brief Empty destructor */
-    ~ImageGrabber () throw () {}
+    ~ImageGrabber () noexcept {}
     
     // Inherited from FileGrabber
     const typename pcl::PointCloud<PointT>::ConstPtr

io/include/pcl/io/image_ir.h

@@ -63,7 +63,7 @@ namespace pcl
         IRImage (FrameWrapper::Ptr ir_metadata);
         IRImage (FrameWrapper::Ptr ir_metadata, Timestamp time);
 
-        ~IRImage () throw ()
+        ~IRImage () noexcept
         {}
 
         void

io/include/pcl/io/image_rgb24.h

@@ -55,7 +55,7 @@ namespace pcl
 
         ImageRGB24 (FrameWrapper::Ptr image_metadata);
         ImageRGB24 (FrameWrapper::Ptr image_metadata, Timestamp timestamp);
-        ~ImageRGB24 () throw ();
+        ~ImageRGB24 () noexcept;
 
         inline Encoding
         getEncoding () const override

io/include/pcl/io/image_yuv422.h

@@ -55,7 +55,7 @@ namespace pcl
         ImageYUV422 (FrameWrapper::Ptr image_metadata);
         ImageYUV422 (FrameWrapper::Ptr image_metadata, Timestamp timestamp);
 
-        ~ImageYUV422 () throw ();
+        ~ImageYUV422 () noexcept;
 
         inline Encoding
         getEncoding () const override

io/include/pcl/io/io_exception.h

@@ -67,7 +67,7 @@ namespace pcl
           unsigned line_number,
           const std::string& message);
 
-        ~IOException () throw ();
+        ~IOException () noexcept;
 
         IOException&
         operator= (const IOException& exception);

io/include/pcl/io/oni_grabber.h

@@ -88,7 +88,7 @@ namespace pcl
       ONIGrabber (const std::string& file_name, bool repeat, bool stream);
 
       /** \brief destructor never throws an exception */
-      ~ONIGrabber () throw ();
+      ~ONIGrabber () noexcept;
 
       /** \brief For devices that are streaming, the streams are started by calling this method.
         *        Trigger-based devices, just trigger the device once for each call of start.

io/include/pcl/io/openni2_grabber.h

@@ -147,7 +147,7 @@ namespace pcl
           const Mode& image_mode = OpenNI_Default_Mode);
 
         /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
-        ~OpenNI2Grabber () throw ();
+        ~OpenNI2Grabber () noexcept;
 
         /** \brief Start the data acquisition. */
         void

io/include/pcl/io/openni_camera/openni_depth_image.h

@@ -69,10 +69,10 @@ namespace openni_wrapper
         * \param[in] no_sample_value defines which values in the depth data are indicating that no depth (disparity) could be determined .
         * \attention The focal length may change, depending whether the depth stream is registered/mapped to the RGB stream or not.
         */
-      inline DepthImage (pcl::shared_ptr<xn::DepthMetaData> depth_meta_data, float baseline, float focal_length, XnUInt64 shadow_value, XnUInt64 no_sample_value) throw ();
+      inline DepthImage (pcl::shared_ptr<xn::DepthMetaData> depth_meta_data, float baseline, float focal_length, XnUInt64 shadow_value, XnUInt64 no_sample_value) noexcept;
 
       /** \brief Destructor. Never throws an exception. */
-      inline virtual ~DepthImage () throw ();
+      inline virtual ~DepthImage () noexcept;
 
       /** \brief method to access the internal data structure from OpenNI. If the data is accessed just read-only, then this method is faster than a fillXXX method
         * \return the actual depth data of type xn::DepthMetaData.
@@ -163,14 +163,14 @@ namespace openni_wrapper
       XnUInt64 no_sample_value_;
   } ;
 
-  DepthImage::DepthImage (pcl::shared_ptr<xn::DepthMetaData> depth_meta_data, float baseline, float focal_length, XnUInt64 shadow_value, XnUInt64 no_sample_value) throw ()
+  DepthImage::DepthImage (pcl::shared_ptr<xn::DepthMetaData> depth_meta_data, float baseline, float focal_length, XnUInt64 shadow_value, XnUInt64 no_sample_value) noexcept
   : depth_md_ (std::move(depth_meta_data))
   , baseline_ (baseline)
   , focal_length_ (focal_length)
   , shadow_value_ (shadow_value)
   , no_sample_value_ (no_sample_value) { }
 
-  DepthImage::~DepthImage () throw () { }
+  DepthImage::~DepthImage () noexcept { }
 
   const xn::DepthMetaData&
   DepthImage::getDepthMetaData () const throw ()

io/include/pcl/io/openni_camera/openni_device.h

@@ -90,7 +90,7 @@ namespace openni_wrapper
     public:
 
       /** \brief virtual destructor. Never throws an exception. */
-      virtual ~OpenNIDevice () throw ();
+      virtual ~OpenNIDevice () noexcept;
 
       /** \brief finds an image output mode that can be used to retrieve images in desired output mode.
         *        e.g If device just supports VGA at 30Hz, then the desired mode QVGA at 30Hz would be possible by down sampling,
@@ -290,7 +290,7 @@ namespace openni_wrapper
         * \return a callback handler that can be used to remove the user callback from list of image-stream callbacks.
         */
       CallbackHandle 
-      registerImageCallback (const ImageCallbackFunction& callback, void* cookie = nullptr) throw ();
+      registerImageCallback (const ImageCallbackFunction& callback, void* cookie = nullptr) noexcept;
 
       /** \brief registers a callback function for the image stream with an optional user defined parameter.
         *        This version is used to register a member function of any class.
@@ -301,14 +301,14 @@ namespace openni_wrapper
         * \return a callback handler that can be used to remove the user callback from list of image-stream callbacks.
         */
       template<typename T> CallbackHandle 
-      registerImageCallback (void (T::*callback)(Image::Ptr, void* cookie), T& instance, void* cookie = nullptr) throw ();
+      registerImageCallback (void (T::*callback)(Image::Ptr, void* cookie), T& instance, void* cookie = nullptr) noexcept;
 
       /** \brief unregisters a callback function. i.e. removes that function from the list of image stream callbacks.
         * \param[in] callbackHandle the handle of the callback to unregister.
         * \return true, if callback was in list and could be unregistered, false otherwise.
         */
       bool 
-      unregisterImageCallback (const CallbackHandle& callbackHandle) throw ();
+      unregisterImageCallback (const CallbackHandle& callbackHandle) noexcept;
 
 
       /** \brief registers a callback function of std::function type for the depth stream with an optional user defined parameter.
@@ -318,7 +318,7 @@ namespace openni_wrapper
         * \return a callback handler that can be used to remove the user callback from list of depth-stream callbacks.
         */
       CallbackHandle 
-      registerDepthCallback (const DepthImageCallbackFunction& callback, void* cookie = nullptr) throw ();
+      registerDepthCallback (const DepthImageCallbackFunction& callback, void* cookie = nullptr) noexcept;
 
       /** \brief registers a callback function for the depth stream with an optional user defined parameter.
         *        This version is used to register a member function of any class.
@@ -329,14 +329,14 @@ namespace openni_wrapper
         * \return a callback handler that can be used to remove the user callback from list of depth-stream callbacks.
         */
       template<typename T> CallbackHandle 
-      registerDepthCallback (void (T::*callback)(DepthImage::Ptr, void* cookie), T& instance, void* cookie = nullptr) throw ();
+      registerDepthCallback (void (T::*callback)(DepthImage::Ptr, void* cookie), T& instance, void* cookie = nullptr) noexcept;
 
       /** \brief unregisters a callback function. i.e. removes that function from the list of depth stream callbacks.
         * \param[in] callbackHandle the handle of the callback to unregister.
         * \return true, if callback was in list and could be unregistered, false otherwise.
         */
       bool 
-      unregisterDepthCallback (const CallbackHandle& callbackHandle) throw ();
+      unregisterDepthCallback (const CallbackHandle& callbackHandle) noexcept;
 
       /** \brief registers a callback function of std::function type for the IR stream with an optional user defined parameter.
         *        The callback will always be called with a new IR image and the user data "cookie".
@@ -345,7 +345,7 @@ namespace openni_wrapper
         * \return a callback handler that can be used to remove the user callback from list of IR-stream callbacks.
         */
       CallbackHandle 
-      registerIRCallback (const IRImageCallbackFunction& callback, void* cookie = nullptr) throw ();
+      registerIRCallback (const IRImageCallbackFunction& callback, void* cookie = nullptr) noexcept;
 
       /** \brief registers a callback function for the IR stream with an optional user defined parameter.
         *        This version is used to register a member function of any class.
@@ -356,14 +356,14 @@ namespace openni_wrapper
         * \return a callback handler that can be used to remove the user callback from list of IR-stream callbacks.
         */
       template<typename T> CallbackHandle 
-      registerIRCallback (void (T::*callback)(IRImage::Ptr, void* cookie), T& instance, void* cookie = nullptr) throw ();
+      registerIRCallback (void (T::*callback)(IRImage::Ptr, void* cookie), T& instance, void* cookie = nullptr) noexcept;
 
       /** \brief unregisters a callback function. i.e. removes that function from the list of IR stream callbacks.
         * \param[in] callbackHandle the handle of the callback to unregister.
         * \return true, if callback was in list and could be unregistered, false otherwise.
         */
       bool 
-      unregisterIRCallback (const CallbackHandle& callbackHandle) throw ();
+      unregisterIRCallback (const CallbackHandle& callbackHandle) noexcept;
 
       /** \brief returns the serial number for device.
         * \attention This might be an empty string!!!
@@ -455,9 +455,9 @@ namespace openni_wrapper
       OpenNIDevice (xn::Context& context, const xn::NodeInfo& device_node, const xn::NodeInfo& image_node, const xn::NodeInfo& depth_node, const xn::NodeInfo& ir_node);
       OpenNIDevice (xn::Context& context, const xn::NodeInfo& device_node, const xn::NodeInfo& depth_node, const xn::NodeInfo& ir_node);
       OpenNIDevice (xn::Context& context);
-      static void __stdcall NewDepthDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
-      static void __stdcall NewImageDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
-      static void __stdcall NewIRDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
+      static void __stdcall NewDepthDataAvailable (xn::ProductionNode& node, void* cookie) noexcept;
+      static void __stdcall NewImageDataAvailable (xn::ProductionNode& node, void* cookie) noexcept;
+      static void __stdcall NewIRDataAvailable (xn::ProductionNode& node, void* cookie) noexcept;
 
       // This is a workaround, since in the NewDepthDataAvailable function WaitAndUpdateData leads to a dead-lock behaviour
       // and retrieving image data without WaitAndUpdateData leads to incomplete images!!!
@@ -593,7 +593,7 @@ namespace openni_wrapper
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   template<typename T> OpenNIDevice::CallbackHandle
-  OpenNIDevice::registerImageCallback (void (T::*callback)(Image::Ptr, void* cookie), T& instance, void* custom_data) throw ()
+  OpenNIDevice::registerImageCallback (void (T::*callback)(Image::Ptr, void* cookie), T& instance, void* custom_data) noexcept
   {
     image_callback_[image_callback_handle_counter_] = [=, &instance] (Image::Ptr img) { (instance.*callback) (img, custom_data); };
     return (image_callback_handle_counter_++);
@@ -601,7 +601,7 @@ namespace openni_wrapper
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   template<typename T> OpenNIDevice::CallbackHandle
-  OpenNIDevice::registerDepthCallback (void (T::*callback)(DepthImage::Ptr, void* cookie), T& instance, void* custom_data) throw ()
+  OpenNIDevice::registerDepthCallback (void (T::*callback)(DepthImage::Ptr, void* cookie), T& instance, void* custom_data) noexcept
   {
     depth_callback_[depth_callback_handle_counter_] = [=, &instance] (DepthImage::Ptr img) { (instance.*callback) (img, custom_data); };
     return (depth_callback_handle_counter_++);
@@ -609,7 +609,7 @@ namespace openni_wrapper
 
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   template<typename T> OpenNIDevice::CallbackHandle
-  OpenNIDevice::registerIRCallback (void (T::*callback)(IRImage::Ptr, void* cookie), T& instance, void* custom_data) throw ()
+  OpenNIDevice::registerIRCallback (void (T::*callback)(IRImage::Ptr, void* cookie), T& instance, void* custom_data) noexcept
   {
     ir_callback_[ir_callback_handle_counter_] = [=, &instance] (IRImage::Ptr img) { (instance.*callback) (img, custom_data); };
     return (ir_callback_handle_counter_++);

io/include/pcl/io/openni_camera/openni_device_kinect.h

@@ -58,22 +58,22 @@ namespace openni_wrapper
     friend class OpenNIDriver;
   public:
     DeviceKinect (xn::Context& context, const xn::NodeInfo& device_node, const xn::NodeInfo& image_node, const xn::NodeInfo& depth_node, const xn::NodeInfo& ir_node);
-    ~DeviceKinect () throw ();
+    ~DeviceKinect () noexcept;
 
-    inline void setDebayeringMethod (const ImageBayerGRBG::DebayeringMethod& debayering_method) throw ();
+    inline void setDebayeringMethod (const ImageBayerGRBG::DebayeringMethod& debayering_method) noexcept;
     inline const ImageBayerGRBG::DebayeringMethod& getDebayeringMethod () const throw ();
 
     bool isSynchronizationSupported () const throw () override;
 
   protected:
     Image::Ptr getCurrentImage (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) const throw () override;
-    void enumAvailableModes () throw ();
+    void enumAvailableModes () noexcept;
     bool isImageResizeSupported (unsigned input_width, unsigned input_height, unsigned output_width, unsigned output_height) const throw () override;
     ImageBayerGRBG::DebayeringMethod debayering_method_;
   } ;
 
   void
-  DeviceKinect::setDebayeringMethod (const ImageBayerGRBG::DebayeringMethod& debayering_method) throw ()
+  DeviceKinect::setDebayeringMethod (const ImageBayerGRBG::DebayeringMethod& debayering_method) noexcept
   {
     debayering_method_ = debayering_method;
   }

io/include/pcl/io/openni_camera/openni_device_oni.h

@@ -66,7 +66,7 @@ namespace openni_wrapper
     using ConstPtr = pcl::shared_ptr<const DeviceONI>;
 
     DeviceONI (xn::Context& context, const std::string& file_name, bool repeat = false, bool streaming = true);
-    ~DeviceONI () throw ();
+    ~DeviceONI () noexcept;
 
     void startImageStream () override;
     void stopImageStream () override;
@@ -102,9 +102,9 @@ namespace openni_wrapper
     Image::Ptr getCurrentImage (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) const throw () override;
 
     void PlayerThreadFunction ();
-    static void __stdcall NewONIDepthDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
-    static void __stdcall NewONIImageDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
-    static void __stdcall NewONIIRDataAvailable (xn::ProductionNode& node, void* cookie) throw ();
+    static void __stdcall NewONIDepthDataAvailable (xn::ProductionNode& node, void* cookie) noexcept;
+    static void __stdcall NewONIImageDataAvailable (xn::ProductionNode& node, void* cookie) noexcept;
+    static void __stdcall NewONIIRDataAvailable (xn::ProductionNode& node, void* cookie) noexcept;
 
     xn::Player player_;
     std::thread player_thread_;

io/include/pcl/io/openni_camera/openni_device_primesense.h

@@ -59,12 +59,12 @@ class DevicePrimesense : public OpenNIDevice
   friend class OpenNIDriver;
 public:
   DevicePrimesense (xn::Context& context, const xn::NodeInfo& device_node, const xn::NodeInfo& image_node, const xn::NodeInfo& depth_node, const xn::NodeInfo& ir_node);
-  ~DevicePrimesense () throw ();
+  ~DevicePrimesense () noexcept;
   //virtual void setImageOutputMode (const XnMapOutputMode& output_mode);
 
 protected:
   Image::Ptr getCurrentImage (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) const throw () override;
-  void enumAvailableModes () throw ();
+  void enumAvailableModes () noexcept;
   bool isImageResizeSupported (unsigned input_width, unsigned input_height, unsigned output_width, unsigned output_height) const throw () override;
 
   void startImageStream () override;

io/include/pcl/io/openni_camera/openni_device_xtion.h

@@ -61,12 +61,12 @@ namespace openni_wrapper
     friend class OpenNIDriver;
   public:
     DeviceXtionPro (xn::Context& context, const xn::NodeInfo& device_node, const xn::NodeInfo& depth_node, const xn::NodeInfo& ir_node);
-    ~DeviceXtionPro () throw ();
+    ~DeviceXtionPro () noexcept;
     //virtual void setImageOutputMode (const XnMapOutputMode& output_mode);
 
   protected:
     Image::Ptr getCurrentImage (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) const throw () override;
-    void enumAvailableModes () throw ();
+    void enumAvailableModes () noexcept;
     bool isImageResizeSupported (unsigned input_width, unsigned input_height, unsigned output_width, unsigned output_height) const throw () override;
 
     void startDepthStream () override;

io/include/pcl/io/openni_camera/openni_driver.h

@@ -68,7 +68,7 @@ namespace openni_wrapper
      * @author Suat Gedikli
      * @brief virtual Destructor that never throws an exception
      */
-    ~OpenNIDriver () throw ();
+    ~OpenNIDriver () noexcept;
 
     /**
      * @author Suat Gedikli
@@ -225,7 +225,7 @@ namespace openni_wrapper
 
 #ifndef _WIN32
     // workaround to get additional device nformation like serial number, vendor and product name, until Primesense fix this
-    void getDeviceInfos () throw ();
+    void getDeviceInfos () noexcept;
 #endif
 
     mutable std::vector<DeviceContext> device_context_;

io/include/pcl/io/openni_camera/openni_exception.h

@@ -75,19 +75,19 @@ namespace openni_wrapper
      * @param[in] line_number the line number where this exception was created.
      * @param[in] message the message of the exception
      */
-    OpenNIException (const std::string& function_name, const std::string& file_name, unsigned line_number, const std::string& message) throw ();
+    OpenNIException (const std::string& function_name, const std::string& file_name, unsigned line_number, const std::string& message) noexcept;
 
     /**
      * @brief virtual Destructor that never throws an exception
      */
-    ~OpenNIException () throw ();
+    ~OpenNIException () noexcept;
 
     /**
      * @brief Assignment operator to allow copying the message of another exception variable.
      * @param[in] exception left hand side
      * @return
      */
-    OpenNIException & operator= (const OpenNIException& exception) throw ();
+    OpenNIException & operator= (const OpenNIException& exception) noexcept;
 
     /**
      * @brief virtual method, derived from std::exception

io/include/pcl/io/openni_camera/openni_image.h

@@ -74,13 +74,13 @@ namespace openni_wrapper
      * @brief Constructor
      * @param[in] image_meta_data the actual image data from the OpenNI driver
      */
-    inline Image (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) throw ();
+    inline Image (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) noexcept;
 
     /**
      * @author Suat Gedikli
      * @brief virtual Destructor that never throws an exception.
      */
-    inline virtual ~Image () throw ();
+    inline virtual ~Image () noexcept;
 
     /**
      * @author Suat Gedikli
@@ -169,12 +169,12 @@ namespace openni_wrapper
     pcl::shared_ptr<xn::ImageMetaData> image_md_;
   } ;
 
-  Image::Image (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) throw ()
+  Image::Image (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) noexcept
   : image_md_ (std::move(image_meta_data))
   {
   }
 
-  Image::~Image () throw () { }
+  Image::~Image () noexcept { }
 
   unsigned
   Image::getWidth () const throw ()

io/include/pcl/io/openni_camera/openni_image_bayer_grbg.h

@@ -61,8 +61,8 @@ namespace openni_wrapper
         EdgeAwareWeighted
       };
 
-      ImageBayerGRBG (pcl::shared_ptr<xn::ImageMetaData> image_meta_data, DebayeringMethod method) throw ();
-      ~ImageBayerGRBG () throw ();
+      ImageBayerGRBG (pcl::shared_ptr<xn::ImageMetaData> image_meta_data, DebayeringMethod method) noexcept;
+      ~ImageBayerGRBG () noexcept;
 
       inline Encoding
       getEncoding () const override
@@ -73,7 +73,7 @@ namespace openni_wrapper
       void fillRGB (unsigned width, unsigned height, unsigned char* rgb_buffer, unsigned rgb_line_step = 0) const override;
       void fillGrayscale (unsigned width, unsigned height, unsigned char* gray_buffer, unsigned gray_line_step = 0) const override;
       bool isResizingSupported (unsigned input_width, unsigned input_height, unsigned output_width, unsigned output_height) const override;
-      inline void setDebayeringMethod (const DebayeringMethod& method) throw ();
+      inline void setDebayeringMethod (const DebayeringMethod& method) noexcept;
       inline DebayeringMethod getDebayeringMethod () const throw ();
       inline static bool resizingSupported (unsigned input_width, unsigned input_height, unsigned output_width, unsigned output_height);
 
@@ -83,7 +83,7 @@ namespace openni_wrapper
   };
 
   void
-  ImageBayerGRBG::setDebayeringMethod (const ImageBayerGRBG::DebayeringMethod& method) throw ()
+  ImageBayerGRBG::setDebayeringMethod (const ImageBayerGRBG::DebayeringMethod& method) noexcept
   {
     debayering_method_ = method;
   }

io/include/pcl/io/openni_camera/openni_image_rgb24.h

@@ -56,8 +56,8 @@ namespace openni_wrapper
   {
   public:
 
-    ImageRGB24 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) throw ();
-    ~ImageRGB24 () throw ();
+    ImageRGB24 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) noexcept;
+    ~ImageRGB24 () noexcept;
 
     inline Encoding
     getEncoding () const override

io/include/pcl/io/openni_camera/openni_image_yuv_422.h

@@ -55,8 +55,8 @@ namespace openni_wrapper
   class PCL_EXPORTS ImageYUV422 : public Image
   {
   public:
-    ImageYUV422 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) throw ();
-    ~ImageYUV422 () throw ();
+    ImageYUV422 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) noexcept;
+    ~ImageYUV422 () noexcept;
 
     inline Encoding
     getEncoding () const override

io/include/pcl/io/openni_camera/openni_ir_image.h

@@ -55,8 +55,8 @@ public:
   using Ptr = pcl::shared_ptr<IRImage>;
   using ConstPtr = pcl::shared_ptr<const IRImage>;
 
-  inline IRImage (pcl::shared_ptr<xn::IRMetaData> ir_meta_data) throw ();
-  inline virtual ~IRImage () throw ();
+  inline IRImage (pcl::shared_ptr<xn::IRMetaData> ir_meta_data) noexcept;
+  inline virtual ~IRImage () noexcept;
 
   void fillRaw (unsigned width, unsigned height, unsigned short* ir_buffer, unsigned line_step = 0) const;
 
@@ -70,12 +70,12 @@ protected:
   pcl::shared_ptr<xn::IRMetaData> ir_md_;
 };
 
-IRImage::IRImage (pcl::shared_ptr<xn::IRMetaData> ir_meta_data) throw ()
+IRImage::IRImage (pcl::shared_ptr<xn::IRMetaData> ir_meta_data) noexcept
 : ir_md_ (std::move(ir_meta_data))
 {
 }
 
-IRImage::~IRImage () throw ()
+IRImage::~IRImage () noexcept
 {
 }
 

io/include/pcl/io/openni_grabber.h

@@ -109,7 +109,7 @@ namespace pcl
                      const Mode& image_mode = OpenNI_Default_Mode);
 
       /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
-      ~OpenNIGrabber () throw ();
+      ~OpenNIGrabber () noexcept;
 
       /** \brief Start the data acquisition. */
       void

io/include/pcl/io/pcd_grabber.h

@@ -96,7 +96,7 @@ namespace pcl
       }
 
       /** \brief Virtual destructor. */
-      ~PCDGrabberBase () throw ();
+      ~PCDGrabberBase () noexcept;
 
       /** \brief Starts playing the list of PCD files if frames_per_second is > 0. Otherwise it works as a trigger: publishes only the next PCD file in the list. */
       void 
@@ -164,7 +164,7 @@ namespace pcl
       PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second = 0, bool repeat = false);
       
       /** \brief Virtual destructor. */
-      ~PCDGrabber () throw ()
+      ~PCDGrabber () noexcept
       {
         stop ();
       }

io/include/pcl/io/real_sense_grabber.h

@@ -140,7 +140,7 @@ namespace pcl
       RealSenseGrabber (const std::string& device_id = "", const Mode& mode = Mode (), bool strict = false);
 
       virtual
-      ~RealSenseGrabber () throw ();
+      ~RealSenseGrabber () noexcept;
 
       virtual void
       start ();

io/include/pcl/io/robot_eye_grabber.h

@@ -72,7 +72,7 @@ namespace pcl
       RobotEyeGrabber (const boost::asio::ip::address& ipAddress, unsigned short port=443);
 
       /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
-      ~RobotEyeGrabber () throw ();
+      ~RobotEyeGrabber () noexcept;
 
       /** \brief Starts the RobotEye grabber.
        * The grabber runs on a separate thread, this call will return without blocking. */

io/include/pcl/io/vlp_grabber.h

@@ -71,7 +71,7 @@ namespace pcl
 
       /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
       
-      ~VLPGrabber () throw ();
+      ~VLPGrabber () noexcept;
 
       /** \brief Obtains the name of this I/O Grabber
        *  \return The name of the grabber

io/src/davidsdk_grabber.cpp

@@ -68,7 +68,7 @@ pcl::DavidSDKGrabber::DavidSDKGrabber () :
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-pcl::DavidSDKGrabber::~DavidSDKGrabber () throw ()
+pcl::DavidSDKGrabber::~DavidSDKGrabber () noexcept
 {
   try
   {

io/src/depth_sense/depth_sense_grabber_impl.cpp

@@ -59,7 +59,7 @@ pcl::io::depth_sense::DepthSenseGrabberImpl::DepthSenseGrabberImpl (DepthSenseGr
   point_cloud_rgba_signal_ = p_->createSignal<sig_cb_depth_sense_point_cloud_rgba> ();
 }
 
-pcl::io::depth_sense::DepthSenseGrabberImpl::~DepthSenseGrabberImpl () throw ()
+pcl::io::depth_sense::DepthSenseGrabberImpl::~DepthSenseGrabberImpl () noexcept
 {
   stop ();
 

io/src/depth_sense_grabber.cpp

@@ -44,7 +44,7 @@ pcl::DepthSenseGrabber::DepthSenseGrabber (const std::string& device_id)
 {
 }
 
-pcl::DepthSenseGrabber::~DepthSenseGrabber () throw ()
+pcl::DepthSenseGrabber::~DepthSenseGrabber () noexcept
 {
   delete p_;
 }

io/src/dinast_grabber.cpp

@@ -62,7 +62,7 @@ pcl::DinastGrabber::DinastGrabber (const int device_position)
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-pcl::DinastGrabber::~DinastGrabber () throw ()
+pcl::DinastGrabber::~DinastGrabber () noexcept
 {
   try
   {

io/src/ensenso_grabber.cpp

@@ -85,7 +85,7 @@ pcl::EnsensoGrabber::EnsensoGrabber () :
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-pcl::EnsensoGrabber::~EnsensoGrabber () throw ()
+pcl::EnsensoGrabber::~EnsensoGrabber () noexcept
 {
   try
   {

io/src/hdl_grabber.cpp

@@ -116,7 +116,7 @@ pcl::HDLGrabber::HDLGrabber (const boost::asio::ip::address& ipAddress,
 }
 
 /////////////////////////////////////////////////////////////////////////////
-pcl::HDLGrabber::~HDLGrabber () throw ()
+pcl::HDLGrabber::~HDLGrabber () noexcept
 {
   stop ();
 

io/src/image_grabber.cpp

@@ -848,7 +848,7 @@ pcl::ImageGrabberBase::ImageGrabberBase (const std::vector<std::string>& depth_i
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-pcl::ImageGrabberBase::~ImageGrabberBase () throw ()
+pcl::ImageGrabberBase::~ImageGrabberBase () noexcept
 {
   stop ();
   delete impl_;

io/src/image_rgb24.cpp

@@ -55,7 +55,7 @@ pcl::io::ImageRGB24::ImageRGB24 (FrameWrapper::Ptr image_metadata, Timestamp tim
 {}
 
 
-pcl::io::ImageRGB24::~ImageRGB24 () throw ()
+pcl::io::ImageRGB24::~ImageRGB24 () noexcept
 {}
 
 bool

io/src/image_yuv422.cpp

@@ -57,7 +57,7 @@ pcl::io::ImageYUV422::ImageYUV422 (FrameWrapper::Ptr image_metadata, Timestamp t
 {}
 
 
-pcl::io::ImageYUV422::~ImageYUV422 () throw ()
+pcl::io::ImageYUV422::~ImageYUV422 () noexcept
 {}
 
 bool

io/src/io_exception.cpp

@@ -47,7 +47,7 @@ pcl::io::IOException::IOException (const std::string& function_name, const std::
   message_long_ = sstream.str ();
 }
 
-pcl::io::IOException::~IOException () throw ()
+pcl::io::IOException::~IOException () noexcept
 {
 }
 

io/src/oni_grabber.cpp

@@ -140,7 +140,7 @@ ONIGrabber::ONIGrabber (const std::string& file_name, bool repeat, bool stream)
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-ONIGrabber::~ONIGrabber() throw ()
+ONIGrabber::~ONIGrabber() noexcept
 {
   try
   {

io/src/openni2_grabber.cpp

@@ -139,7 +139,7 @@ pcl::io::OpenNI2Grabber::OpenNI2Grabber (const std::string& device_id, const Mod
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-pcl::io::OpenNI2Grabber::~OpenNI2Grabber () throw ()
+pcl::io::OpenNI2Grabber::~OpenNI2Grabber () noexcept
 {
   try
   {

io/src/openni_camera/openni_device.cpp

@@ -274,7 +274,7 @@ openni_wrapper::OpenNIDevice::OpenNIDevice (xn::Context& context)
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-openni_wrapper::OpenNIDevice::~OpenNIDevice () throw ()
+openni_wrapper::OpenNIDevice::~OpenNIDevice () noexcept
 {
   // stop streams
   if (image_generator_.IsValid() && image_generator_.IsGenerating ())
@@ -910,7 +910,7 @@ openni_wrapper::OpenNIDevice::IRDataThreadFunction ()
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void __stdcall 
-openni_wrapper::OpenNIDevice::NewDepthDataAvailable (xn::ProductionNode&, void* cookie) throw ()
+openni_wrapper::OpenNIDevice::NewDepthDataAvailable (xn::ProductionNode&, void* cookie) noexcept
 {
   OpenNIDevice* device = reinterpret_cast<OpenNIDevice*>(cookie);
   device->depth_condition_.notify_all ();
@@ -918,7 +918,7 @@ openni_wrapper::OpenNIDevice::NewDepthDataAvailable (xn::ProductionNode&, void*
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void __stdcall 
-openni_wrapper::OpenNIDevice::NewImageDataAvailable (xn::ProductionNode&, void* cookie) throw ()
+openni_wrapper::OpenNIDevice::NewImageDataAvailable (xn::ProductionNode&, void* cookie) noexcept
 {
   OpenNIDevice* device = reinterpret_cast<OpenNIDevice*>(cookie);
   device->image_condition_.notify_all ();
@@ -926,7 +926,7 @@ openni_wrapper::OpenNIDevice::NewImageDataAvailable (xn::ProductionNode&, void*
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void __stdcall 
-openni_wrapper::OpenNIDevice::NewIRDataAvailable (xn::ProductionNode&, void* cookie) throw ()
+openni_wrapper::OpenNIDevice::NewIRDataAvailable (xn::ProductionNode&, void* cookie) noexcept
 {
   OpenNIDevice* device = reinterpret_cast<OpenNIDevice*>(cookie);
   device->ir_condition_.notify_all ();
@@ -934,7 +934,7 @@ openni_wrapper::OpenNIDevice::NewIRDataAvailable (xn::ProductionNode&, void* coo
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 openni_wrapper::OpenNIDevice::CallbackHandle 
-openni_wrapper::OpenNIDevice::registerImageCallback (const ImageCallbackFunction& callback, void* custom_data) throw ()
+openni_wrapper::OpenNIDevice::registerImageCallback (const ImageCallbackFunction& callback, void* custom_data) noexcept
 {
   image_callback_[image_callback_handle_counter_] = [=] (const Image::Ptr& img) { callback (img, custom_data); };
   return (image_callback_handle_counter_++);
@@ -942,14 +942,14 @@ openni_wrapper::OpenNIDevice::registerImageCallback (const ImageCallbackFunction
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 bool 
-openni_wrapper::OpenNIDevice::unregisterImageCallback (const OpenNIDevice::CallbackHandle& callbackHandle) throw ()
+openni_wrapper::OpenNIDevice::unregisterImageCallback (const OpenNIDevice::CallbackHandle& callbackHandle) noexcept
 {
   return (image_callback_.erase (callbackHandle) != 0);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 openni_wrapper::OpenNIDevice::CallbackHandle 
-openni_wrapper::OpenNIDevice::registerDepthCallback (const DepthImageCallbackFunction& callback, void* custom_data) throw ()
+openni_wrapper::OpenNIDevice::registerDepthCallback (const DepthImageCallbackFunction& callback, void* custom_data) noexcept
 {
   depth_callback_[depth_callback_handle_counter_] = [=] (const DepthImage::Ptr& img) { callback (img, custom_data); };
   return (depth_callback_handle_counter_++);
@@ -957,14 +957,14 @@ openni_wrapper::OpenNIDevice::registerDepthCallback (const DepthImageCallbackFun
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 bool 
-openni_wrapper::OpenNIDevice::unregisterDepthCallback (const OpenNIDevice::CallbackHandle& callbackHandle) throw ()
+openni_wrapper::OpenNIDevice::unregisterDepthCallback (const OpenNIDevice::CallbackHandle& callbackHandle) noexcept
 {
   return (depth_callback_.erase (callbackHandle) != 0);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 openni_wrapper::OpenNIDevice::CallbackHandle 
-openni_wrapper::OpenNIDevice::registerIRCallback (const IRImageCallbackFunction& callback, void* custom_data) throw ()
+openni_wrapper::OpenNIDevice::registerIRCallback (const IRImageCallbackFunction& callback, void* custom_data) noexcept
 {
   ir_callback_[ir_callback_handle_counter_] = [=] (const IRImage::Ptr& img) { callback (img, custom_data); };
   return (ir_callback_handle_counter_++);
@@ -972,7 +972,7 @@ openni_wrapper::OpenNIDevice::registerIRCallback (const IRImageCallbackFunction&
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 bool 
-openni_wrapper::OpenNIDevice::unregisterIRCallback (const OpenNIDevice::CallbackHandle& callbackHandle) throw ()
+openni_wrapper::OpenNIDevice::unregisterIRCallback (const OpenNIDevice::CallbackHandle& callbackHandle) noexcept
 {
   return (ir_callback_.erase (callbackHandle) != 0);
 }

io/src/openni_camera/openni_device_kinect.cpp

@@ -92,7 +92,7 @@ openni_wrapper::DeviceKinect::DeviceKinect (xn::Context& context, const xn::Node
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-openni_wrapper::DeviceKinect::~DeviceKinect () throw ()
+openni_wrapper::DeviceKinect::~DeviceKinect () noexcept
 {
   depth_mutex_.lock ();
   depth_generator_.UnregisterFromNewDataAvailable (depth_callback_handle_);
@@ -112,7 +112,7 @@ openni_wrapper::DeviceKinect::isImageResizeSupported (unsigned input_width, unsi
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void 
-openni_wrapper::DeviceKinect::enumAvailableModes () throw ()
+openni_wrapper::DeviceKinect::enumAvailableModes () noexcept
 {
   XnMapOutputMode output_mode;
   available_image_modes_.clear();

io/src/openni_camera/openni_device_oni.cpp

@@ -102,7 +102,7 @@ openni_wrapper::DeviceONI::DeviceONI (
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-openni_wrapper::DeviceONI::~DeviceONI() throw ()
+openni_wrapper::DeviceONI::~DeviceONI() noexcept
 {
   if (streaming_)
   {
@@ -221,7 +221,7 @@ openni_wrapper::DeviceONI::PlayerThreadFunction ()
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void __stdcall 
-openni_wrapper::DeviceONI::NewONIDepthDataAvailable (xn::ProductionNode&, void* cookie) throw ()
+openni_wrapper::DeviceONI::NewONIDepthDataAvailable (xn::ProductionNode&, void* cookie) noexcept
 {
   DeviceONI* device = reinterpret_cast<DeviceONI*>(cookie);
   if (device->depth_stream_running_)
@@ -230,7 +230,7 @@ openni_wrapper::DeviceONI::NewONIDepthDataAvailable (xn::ProductionNode&, void*
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void __stdcall 
-openni_wrapper::DeviceONI::NewONIImageDataAvailable (xn::ProductionNode&, void* cookie) throw ()
+openni_wrapper::DeviceONI::NewONIImageDataAvailable (xn::ProductionNode&, void* cookie) noexcept
 {
   DeviceONI* device = reinterpret_cast<DeviceONI*> (cookie);
   if (device->image_stream_running_)
@@ -239,7 +239,7 @@ openni_wrapper::DeviceONI::NewONIImageDataAvailable (xn::ProductionNode&, void*
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void __stdcall 
-openni_wrapper::DeviceONI::NewONIIRDataAvailable (xn::ProductionNode&, void* cookie) throw ()
+openni_wrapper::DeviceONI::NewONIIRDataAvailable (xn::ProductionNode&, void* cookie) noexcept
 {
   DeviceONI* device = reinterpret_cast<DeviceONI*> (cookie);
   if (device->ir_stream_running_)

io/src/openni_camera/openni_device_primesense.cpp

@@ -83,7 +83,7 @@ openni_wrapper::DevicePrimesense::DevicePrimesense (
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-openni_wrapper::DevicePrimesense::~DevicePrimesense () throw ()
+openni_wrapper::DevicePrimesense::~DevicePrimesense () noexcept
 {
   setDepthRegistration (false);
   setSynchronization (false);
@@ -110,7 +110,7 @@ openni_wrapper::DevicePrimesense::isImageResizeSupported (
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void 
-openni_wrapper::DevicePrimesense::enumAvailableModes () throw ()
+openni_wrapper::DevicePrimesense::enumAvailableModes () noexcept
 {
   XnMapOutputMode output_mode;
   available_image_modes_.clear ();

io/src/openni_camera/openni_device_xtion.cpp

@@ -65,7 +65,7 @@ openni_wrapper::DeviceXtionPro::DeviceXtionPro (xn::Context& context, const xn::
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-openni_wrapper::DeviceXtionPro::~DeviceXtionPro () throw ()
+openni_wrapper::DeviceXtionPro::~DeviceXtionPro () noexcept
 {
   depth_mutex_.lock ();
   depth_generator_.UnregisterFromNewDataAvailable (depth_callback_handle_);
@@ -81,7 +81,7 @@ openni_wrapper::DeviceXtionPro::isImageResizeSupported (unsigned, unsigned, unsi
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void 
-openni_wrapper::DeviceXtionPro::enumAvailableModes () throw ()
+openni_wrapper::DeviceXtionPro::enumAvailableModes () noexcept
 {
   XnMapOutputMode output_mode;
   available_image_modes_.clear();

io/src/openni_camera/openni_driver.cpp

@@ -218,7 +218,7 @@ openni_wrapper::OpenNIDriver::stopAll ()
     THROW_OPENNI_EXCEPTION ("stopping all streams failed. Reason: %s", xnGetStatusString (status));
 }
 
-openni_wrapper::OpenNIDriver::~OpenNIDriver () throw ()
+openni_wrapper::OpenNIDriver::~OpenNIDriver () noexcept
 {
   // no exception during destuctor
   try
@@ -331,7 +331,7 @@ openni_wrapper::OpenNIDriver::getDeviceByAddress (unsigned char bus, unsigned ch
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 void
-openni_wrapper::OpenNIDriver::getDeviceInfos () throw ()
+openni_wrapper::OpenNIDriver::getDeviceInfos () noexcept
 {
   libusb_context *context = nullptr;
   int result;

io/src/openni_camera/openni_exception.cpp

@@ -43,7 +43,7 @@
 namespace openni_wrapper
 {
 
-OpenNIException::OpenNIException (const std::string& function_name, const std::string& file_name, unsigned line_number, const std::string& message) throw ()
+OpenNIException::OpenNIException (const std::string& function_name, const std::string& file_name, unsigned line_number, const std::string& message) noexcept
 : function_name_ (function_name)
 , file_name_ (file_name)
 , line_number_ (line_number)
@@ -54,11 +54,11 @@ OpenNIException::OpenNIException (const std::string& function_name, const std::s
   message_long_ = sstream.str();
 }
 
-OpenNIException::~OpenNIException () throw ()
+OpenNIException::~OpenNIException () noexcept
 {
 }
 
-OpenNIException& OpenNIException::operator = (const OpenNIException& exception) throw ()
+OpenNIException& OpenNIException::operator = (const OpenNIException& exception) noexcept
 {
   message_ = exception.message_;
   return *this;

io/src/openni_camera/openni_image_bayer_grbg.cpp

@@ -51,14 +51,14 @@
 using namespace std;
 
 //////////////////////////////////////////////////////////////////////////////
-openni_wrapper::ImageBayerGRBG::ImageBayerGRBG (pcl::shared_ptr<xn::ImageMetaData> image_meta_data, DebayeringMethod method) throw ()
+openni_wrapper::ImageBayerGRBG::ImageBayerGRBG (pcl::shared_ptr<xn::ImageMetaData> image_meta_data, DebayeringMethod method) noexcept
 : Image (std::move(image_meta_data))
 , debayering_method_ (method)
 {
 }
 
 //////////////////////////////////////////////////////////////////////////////
-openni_wrapper::ImageBayerGRBG::~ImageBayerGRBG () throw ()
+openni_wrapper::ImageBayerGRBG::~ImageBayerGRBG () noexcept
 {
 }
 

io/src/openni_camera/openni_image_rgb24.cpp

@@ -6,12 +6,12 @@
 
 namespace openni_wrapper
 {
-ImageRGB24::ImageRGB24 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) throw ()
+ImageRGB24::ImageRGB24 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) noexcept
 : Image (std::move(image_meta_data))
 {
 }
 
-ImageRGB24::~ImageRGB24 () throw ()
+ImageRGB24::~ImageRGB24 () noexcept
 {
 }
 

io/src/openni_camera/openni_image_yuv_422.cpp

@@ -48,12 +48,12 @@ using namespace std;
 namespace openni_wrapper
 {
 
-ImageYUV422::ImageYUV422 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) throw ()
+ImageYUV422::ImageYUV422 (pcl::shared_ptr<xn::ImageMetaData> image_meta_data) noexcept
 : Image (std::move(image_meta_data))
 {
 }
 
-ImageYUV422::~ImageYUV422 () throw ()
+ImageYUV422::~ImageYUV422 () noexcept
 {
 }
 

io/src/openni_grabber.cpp

@@ -121,7 +121,7 @@ pcl::OpenNIGrabber::OpenNIGrabber (const std::string& device_id, const Mode& dep
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-pcl::OpenNIGrabber::~OpenNIGrabber () throw ()
+pcl::OpenNIGrabber::~OpenNIGrabber () noexcept
 {
   try
   {

io/src/pcd_grabber.cpp

@@ -366,7 +366,7 @@ pcl::PCDGrabberBase::PCDGrabberBase (const std::vector<std::string>& pcd_files,
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-pcl::PCDGrabberBase::~PCDGrabberBase () throw ()
+pcl::PCDGrabberBase::~PCDGrabberBase () noexcept
 {
   delete impl_;
 }

io/src/real_sense_grabber.cpp

@@ -130,7 +130,7 @@ pcl::RealSenseGrabber::RealSenseGrabber (const std::string& device_id, const Mod
   point_cloud_rgba_signal_ = createSignal<sig_cb_real_sense_point_cloud_rgba> ();
 }
 
-pcl::RealSenseGrabber::~RealSenseGrabber () throw ()
+pcl::RealSenseGrabber::~RealSenseGrabber () noexcept
 {
   stop ();
 

io/src/robot_eye_grabber.cpp

@@ -61,7 +61,7 @@ pcl::RobotEyeGrabber::RobotEyeGrabber (const boost::asio::ip::address& ipAddress
 }
 
 /////////////////////////////////////////////////////////////////////////////
-pcl::RobotEyeGrabber::~RobotEyeGrabber () throw ()
+pcl::RobotEyeGrabber::~RobotEyeGrabber () noexcept
 {
   stop ();
   disconnect_all_slots<sig_cb_robot_eye_point_cloud_xyzi> ();

io/src/vlp_grabber.cpp

@@ -58,7 +58,7 @@ pcl::VLPGrabber::VLPGrabber (const boost::asio::ip::address& ipAddress,
 }
 
 /////////////////////////////////////////////////////////////////////////////
-pcl::VLPGrabber::~VLPGrabber () throw ()
+pcl::VLPGrabber::~VLPGrabber () noexcept
 {
 }
 

stereo/include/pcl/stereo/stereo_grabber.h

@@ -88,7 +88,7 @@ public:
   }
 
   /** \brief Virtual destructor. */
-  ~StereoGrabberBase() throw();
+  ~StereoGrabberBase() noexcept;
 
   /** \brief Starts playing the list of Stereo images if frames_per_second is > 0.
    * Otherwise it works as a trigger: publishes only the next pair in the list. */

stereo/src/stereo_grabber.cpp

@@ -152,7 +152,7 @@ pcl::StereoGrabberBase::StereoGrabberBase(
 {}
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-pcl::StereoGrabberBase::~StereoGrabberBase() throw()
+pcl::StereoGrabberBase::~StereoGrabberBase() noexcept
 {
   stop();
   delete impl_;