From 57412c545d984933bcfb61e3ff716f57ec458a98 Mon Sep 17 00:00:00 2001
From: Kunal Tyagi <tyagi.kunal@live.com>
Date: Fri, 18 Oct 2019 16:20:00 +0900
Subject: [PATCH] Replacing boost::int_t with std::int_t

---
 .../include/pcl/cuda/io/disparity_to_cloud.h  |  2 +-
 cuda/io/src/disparity_to_cloud.cu             |  6 +--
 features/include/pcl/features/impl/gfpfh.hpp  |  2 +-
 gpu/people/include/pcl/gpu/people/tree.h      | 10 ++--
 gpu/people/src/trees.cpp                      |  6 +--
 .../pcl/compression/entropy_range_coder.h     | 10 ++--
 io/include/pcl/io/ply/ply.h                   | 12 ++---
 io/include/pcl/io/robot_eye_grabber.h         |  2 +-
 io/src/ascii_io.cpp                           |  2 +-
 io/src/robot_eye_grabber.cpp                  |  6 +--
 .../pcl/outofcore/impl/octree_base.hpp        | 42 ++++++++---------
 .../pcl/outofcore/impl/octree_base_node.hpp   | 40 ++++++++--------
 .../outofcore/impl/octree_disk_container.hpp  |  4 +-
 .../outofcore/impl/octree_ram_container.hpp   | 16 +++----
 outofcore/include/pcl/outofcore/octree_base.h | 46 +++++++++----------
 .../include/pcl/outofcore/octree_base_node.h  | 36 +++++++--------
 .../pcl/outofcore/octree_disk_container.h     |  2 +-
 .../pcl/outofcore/outofcore_base_data.h       | 22 ++++-----
 outofcore/src/outofcore_base_data.cpp         | 22 ++++-----
 outofcore/src/outofcore_node_data.cpp         |  2 +-
 outofcore/tools/outofcore_print.cpp           |  8 ++--
 outofcore/tools/outofcore_process.cpp         |  2 +-
 test/outofcore/test_outofcore.cpp             |  8 ++--
 23 files changed, 154 insertions(+), 154 deletions(-)

diff --git a/cuda/io/include/pcl/cuda/io/disparity_to_cloud.h b/cuda/io/include/pcl/cuda/io/disparity_to_cloud.h
index f999fa7db24..c56c1f155a4 100644
--- a/cuda/io/include/pcl/cuda/io/disparity_to_cloud.h
+++ b/cuda/io/include/pcl/cuda/io/disparity_to_cloud.h
@@ -114,7 +114,7 @@ namespace cuda
                bool downsample = false, int stride = 2, int smoothing_nr_iterations = 0, int smoothing_filter_size = 2);
 
       template <template <typename> class Storage> void
-      compute (const boost::uint16_t* depth_image,
+      compute (const std::uint16_t* depth_image,
                const OpenNIRGB* rgb_image,
                int width, int height,
                float constant,
diff --git a/cuda/io/src/disparity_to_cloud.cu b/cuda/io/src/disparity_to_cloud.cu
index f1bb9a0121d..cdb6e5fb25d 100644
--- a/cuda/io/src/disparity_to_cloud.cu
+++ b/cuda/io/src/disparity_to_cloud.cu
@@ -184,7 +184,7 @@ ComputeXYZRGB::operator () (const Tuple &t)
 
 //////////////////////////////////////////////////////////////////////////
 template <template <typename> class Storage> void
-DisparityToCloud::compute (const boost::uint16_t* depth_image,
+DisparityToCloud::compute (const std::uint16_t* depth_image,
                            const OpenNIRGB* rgb_image,
                            int width, int height,
                            float constant,
@@ -512,14 +512,14 @@ DisparityToCloud::compute<Device> (const boost::shared_ptr<openni_wrapper::Depth
                                      PointCloudAOS<Device>::Ptr &output,
                                      bool downsample, int stridem, int, int);
 template PCL_EXPORTS void
-DisparityToCloud::compute<Host> (const boost::uint16_t* depth_image,
+DisparityToCloud::compute<Host> (const std::uint16_t* depth_image,
                                  const OpenNIRGB* rgb_image,
                                  int width, int height,
                                  float constant,
                                  typename PointCloudAOS<Host>::Ptr &output,
                                  int smoothing_nr_iterations, int smoothing_filter_size);
 template PCL_EXPORTS void
-DisparityToCloud::compute<Device> (const boost::uint16_t* depth_image,
+DisparityToCloud::compute<Device> (const std::uint16_t* depth_image,
                                    const OpenNIRGB* rgb_image,
                                    int width, int height,
                                    float constant,
diff --git a/features/include/pcl/features/impl/gfpfh.hpp b/features/include/pcl/features/impl/gfpfh.hpp
index 80589d7e663..23d02a6743c 100644
--- a/features/include/pcl/features/impl/gfpfh.hpp
+++ b/features/include/pcl/features/impl/gfpfh.hpp
@@ -248,7 +248,7 @@ pcl::GFPFHEstimation<PointInT, PointNT, PointOutT>::computeHIKDistance (const st
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-template <typename PointInT, typename PointNT, typename PointOutT> boost::uint32_t
+template <typename PointInT, typename PointNT, typename PointOutT> std::uint32_t
 pcl::GFPFHEstimation<PointInT, PointNT, PointOutT>::getDominantLabel (const std::vector<int>& indices)
 {
   std::vector<uint32_t> counts (getNumberOfClasses () + 1, 0);
diff --git a/gpu/people/include/pcl/gpu/people/tree.h b/gpu/people/include/pcl/gpu/people/tree.h
index 03352e436af..4b88dbd2aa6 100644
--- a/gpu/people/include/pcl/gpu/people/tree.h
+++ b/gpu/people/include/pcl/gpu/people/tree.h
@@ -63,11 +63,11 @@ namespace pcl
         // ###############################################
         // base data types used in the structures
 
-        using boost::uint8_t;
-        using boost::int16_t;
-        using boost::uint16_t;
-        using boost::int32_t;
-        using boost::uint32_t;
+        using std::uint8_t;
+        using std::int16_t;
+        using std::uint16_t;
+        using std::int32_t;
+        using std::uint32_t;
 
         using Attrib = int16_t;
         using Label = uint8_t;
diff --git a/gpu/people/src/trees.cpp b/gpu/people/src/trees.cpp
index 216e3842d39..b8daa8dea02 100644
--- a/gpu/people/src/trees.cpp
+++ b/gpu/people/src/trees.cpp
@@ -63,9 +63,9 @@ namespace pcl
          */
         struct Tex2Dfetcher
         {
-	  	  Tex2Dfetcher( const boost::uint16_t* dmap, int W, int H ) : m_dmap(dmap), m_W(W), m_H(H) {}
+	  	  Tex2Dfetcher( const std::uint16_t* dmap, int W, int H ) : m_dmap(dmap), m_W(W), m_H(H) {}
 
-          inline boost::uint16_t operator () ( float uf, float vf ) 
+          inline std::uint16_t operator () ( float uf, float vf ) 
           {
             int u = static_cast<int>(uf);
             int v = static_cast<int>(vf);
@@ -76,7 +76,7 @@ namespace pcl
             
             return m_dmap[u+v*m_W]; // this is going to be SLOOOWWW
           }
-          const boost::uint16_t*  m_dmap;
+          const std::uint16_t*  m_dmap;
           const int               m_W;
           const int               m_H;
         };
diff --git a/io/include/pcl/compression/entropy_range_coder.h b/io/include/pcl/compression/entropy_range_coder.h
index 8ead38cb624..a2eff9c6c8b 100644
--- a/io/include/pcl/compression/entropy_range_coder.h
+++ b/io/include/pcl/compression/entropy_range_coder.h
@@ -52,9 +52,9 @@
 namespace pcl
 {
 
-  using boost::uint8_t;
-  using boost::uint32_t;
-  using boost::uint64_t;
+  using std::uint8_t;
+  using std::uint32_t;
+  using std::uint64_t;
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   /** \brief @b AdaptiveRangeCoder compression class
@@ -97,7 +97,7 @@ namespace pcl
     decodeStreamToCharVector (std::istream& inputByteStream_arg, std::vector<char>& outputByteVector_arg);
 
   protected:
-    using DWord = boost::uint32_t; // 4 bytes
+    using DWord = std::uint32_t; // 4 bytes
 
   private:
     /** vector containing compressed data
@@ -162,7 +162,7 @@ namespace pcl
       decodeStreamToCharVector (std::istream& inputByteStream_arg, std::vector<char>& outputByteVector_arg);
 
     protected:
-      using DWord = boost::uint32_t; // 4 bytes
+      using DWord = std::uint32_t; // 4 bytes
 
       /** \brief Helper function to calculate the binary logarithm
        * \param n_arg: some value
diff --git a/io/include/pcl/io/ply/ply.h b/io/include/pcl/io/ply/ply.h
index 632eb49c862..3016031a701 100644
--- a/io/include/pcl/io/ply/ply.h
+++ b/io/include/pcl/io/ply/ply.h
@@ -55,12 +55,12 @@ namespace pcl
   {
     namespace ply 
     {
-      using int8 = boost::int8_t;
-      using int16 = boost::int16_t;
-      using int32 = boost::int32_t;
-      using uint8 = boost::uint8_t;
-      using uint16 = boost::uint16_t;
-      using uint32 = boost::uint32_t;         
+      using int8 = std::int8_t;
+      using int16 = std::int16_t;
+      using int32 = std::int32_t;
+      using uint8 = std::uint8_t;
+      using uint16 = std::uint16_t;
+      using uint32 = std::uint32_t;         
       
       using float32 = float;
       using float64 = double;
diff --git a/io/include/pcl/io/robot_eye_grabber.h b/io/include/pcl/io/robot_eye_grabber.h
index 34a286d1c4f..dea75345d33 100644
--- a/io/include/pcl/io/robot_eye_grabber.h
+++ b/io/include/pcl/io/robot_eye_grabber.h
@@ -144,6 +144,6 @@ namespace pcl
       void socketCallback (const boost::system::error_code& error, std::size_t number_of_bytes);
       void convertPacketData (unsigned char *data_packet, size_t length);
       void computeXYZI (pcl::PointXYZI& point_XYZI, unsigned char* point_data);
-      void computeTimestamp (boost::uint32_t& timestamp, unsigned char* point_data);
+      void computeTimestamp (std::uint32_t& timestamp, unsigned char* point_data);
   };
 }
diff --git a/io/src/ascii_io.cpp b/io/src/ascii_io.cpp
index a963ed8c7fe..97f77960c92 100644
--- a/io/src/ascii_io.cpp
+++ b/io/src/ascii_io.cpp
@@ -243,7 +243,7 @@ pcl::ASCIIReader::parse (
 }
 
 //////////////////////////////////////////////////////////////////////////////
-boost::uint32_t
+std::uint32_t
 pcl::ASCIIReader::typeSize (int type)
 {
   switch (type)
diff --git a/io/src/robot_eye_grabber.cpp b/io/src/robot_eye_grabber.cpp
index febfc41d306..08089c9311b 100644
--- a/io/src/robot_eye_grabber.cpp
+++ b/io/src/robot_eye_grabber.cpp
@@ -178,7 +178,7 @@ pcl::RobotEyeGrabber::convertPacketData (unsigned char *data_packet, size_t leng
     size_t response_size = 6; //"EBRBEP"
     if( !strncmp((char*)(data_packet), "EBRBEP", response_size) )
     {
-      boost::uint32_t timestamp; // counts of a 66 MHz clock since power-on of eye.
+      std::uint32_t timestamp; // counts of a 66 MHz clock since power-on of eye.
       computeTimestamp(timestamp, data_packet + response_size);
       //std::cout << "Timestamp: " << timestamp << std::endl;
       offset = (response_size + sizeof(timestamp));
@@ -247,9 +247,9 @@ pcl::RobotEyeGrabber::computeXYZI (pcl::PointXYZI& point, unsigned char* point_d
 
 /////////////////////////////////////////////////////////////////////////////
 void
-pcl::RobotEyeGrabber::computeTimestamp (boost::uint32_t& timestamp, unsigned char* point_data)
+pcl::RobotEyeGrabber::computeTimestamp (std::uint32_t& timestamp, unsigned char* point_data)
 {
-  boost::uint32_t buffer;
+  std::uint32_t buffer;
   buffer = point_data[0] << 24;
   buffer |= point_data[1] << 16;
   buffer |= point_data[2] << 8;
diff --git a/outofcore/include/pcl/outofcore/impl/octree_base.hpp b/outofcore/include/pcl/outofcore/impl/octree_base.hpp
index 83f6b18f937..3df7096fea4 100644
--- a/outofcore/include/pcl/outofcore/impl/octree_base.hpp
+++ b/outofcore/include/pcl/outofcore/impl/octree_base.hpp
@@ -115,7 +115,7 @@ namespace pcl
       this->enlargeToCube (tmp_min, tmp_max);
 
       //Compute the depth of the tree given the resolution
-      boost::uint64_t depth = this->calculateDepth (tmp_min, tmp_max, resolution_arg);
+      std::uint64_t depth = this->calculateDepth (tmp_min, tmp_max, resolution_arg);
 
       //Create a new outofcore tree
       this->init (depth, tmp_min, tmp_max, root_node_name, coord_sys);
@@ -124,7 +124,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT>
-    OutofcoreOctreeBase<ContainerT, PointT>::OutofcoreOctreeBase (const boost::uint64_t max_depth, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::filesystem::path& root_node_name, const std::string& coord_sys)
+    OutofcoreOctreeBase<ContainerT, PointT>::OutofcoreOctreeBase (const std::uint64_t max_depth, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::filesystem::path& root_node_name, const std::string& coord_sys)
       : root_node_()
       , read_write_mutex_ ()
       , metadata_ (new OutofcoreOctreeBaseMetadata ())
@@ -204,7 +204,7 @@ namespace pcl
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::addDataToLeaf (const AlignedPointTVector& p)
     {
       std::unique_lock < std::shared_timed_mutex > lock (read_write_mutex_);
@@ -220,7 +220,7 @@ namespace pcl
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::addPointCloud (PointCloudConstPtr point_cloud)
     {
       return (addDataToLeaf (point_cloud->points));
@@ -228,7 +228,7 @@ namespace pcl
     
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check)
     {
       uint64_t pt_added = this->root_node_->addPointCloud (input_cloud, skip_bb_check) ;
@@ -239,23 +239,23 @@ namespace pcl
     
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::addPointCloud_and_genLOD (PointCloudConstPtr point_cloud)
     {
       // Lock the tree while writing
       std::unique_lock < std::shared_timed_mutex > lock (read_write_mutex_);
-      boost::uint64_t pt_added = root_node_->addDataToLeaf_and_genLOD (point_cloud->points, false);
+      std::uint64_t pt_added = root_node_->addDataToLeaf_and_genLOD (point_cloud->points, false);
       return (pt_added);
     }
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::addPointCloud_and_genLOD (pcl::PCLPointCloud2::Ptr &input_cloud)
     {
       // Lock the tree while writing
       std::unique_lock < std::shared_timed_mutex > lock (read_write_mutex_);
-      boost::uint64_t pt_added = root_node_->addPointCloud_and_genLOD (input_cloud);
+      std::uint64_t pt_added = root_node_->addPointCloud_and_genLOD (input_cloud);
       
       PCL_DEBUG ("[pcl::outofcore::OutofcoreOctreeBase::%s] Points added %lu, points in input cloud, %lu\n",__FUNCTION__, pt_added, input_cloud->width*input_cloud->height );
  
@@ -266,12 +266,12 @@ namespace pcl
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::addDataToLeaf_and_genLOD (AlignedPointTVector& src)
     {
       // Lock the tree while writing
       std::unique_lock < std::shared_timed_mutex > lock (read_write_mutex_);
-      boost::uint64_t pt_added = root_node_->addDataToLeaf_and_genLOD (src, false);
+      std::uint64_t pt_added = root_node_->addDataToLeaf_and_genLOD (src, false);
       return (pt_added);
     }
 
@@ -287,7 +287,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename Container, typename PointT> void
-    OutofcoreOctreeBase<Container, PointT>::queryFrustum(const double *planes, std::list<std::string>& file_names, const boost::uint32_t query_depth) const
+    OutofcoreOctreeBase<Container, PointT>::queryFrustum(const double *planes, std::list<std::string>& file_names, const std::uint32_t query_depth) const
     {
       std::shared_lock < std::shared_timed_mutex > lock (read_write_mutex_);
       root_node_->queryFrustum (planes, file_names, query_depth);
@@ -301,7 +301,7 @@ namespace pcl
         const Eigen::Vector3d &eye, 
         const Eigen::Matrix4d &view_projection_matrix, 
         std::list<std::string>& file_names, 
-        const boost::uint32_t query_depth) const
+        const std::uint32_t query_depth) const
     {
       std::shared_lock < std::shared_timed_mutex > lock (read_write_mutex_);
       root_node_->queryFrustum (planes, eye, view_projection_matrix, file_names, query_depth);
@@ -310,7 +310,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIncludes (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::uint64_t query_depth, AlignedPointTVector& dst) const
+    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIncludes (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const std::uint64_t query_depth, AlignedPointTVector& dst) const
     {
       std::shared_lock < std::shared_timed_mutex > lock (read_write_mutex_);
       dst.clear ();
@@ -321,7 +321,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIncludes (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob) const
+    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIncludes (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const std::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob) const
     {
       std::shared_lock < std::shared_timed_mutex > lock (read_write_mutex_);
 
@@ -335,7 +335,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIncludes_subsample (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::uint64_t query_depth, const double percent, AlignedPointTVector& dst) const
+    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIncludes_subsample (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const std::uint64_t query_depth, const double percent, AlignedPointTVector& dst) const
     {
       std::shared_lock < std::shared_timed_mutex > lock (read_write_mutex_);
       dst.clear ();
@@ -413,7 +413,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIntersects (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::uint32_t query_depth, std::list<std::string>& bin_name) const
+    OutofcoreOctreeBase<ContainerT, PointT>::queryBBIntersects (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const std::uint32_t query_depth, std::list<std::string>& bin_name) const
     {
       std::shared_lock < std::shared_timed_mutex > lock (read_write_mutex_);
       bin_name.clear ();
@@ -546,7 +546,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> double
-    OutofcoreOctreeBase<ContainerT, PointT>::getVoxelSideLength (const boost::uint64_t& depth) const
+    OutofcoreOctreeBase<ContainerT, PointT>::getVoxelSideLength (const std::uint64_t& depth) const
     {
       Eigen::Vector3d min, max;
       this->getBoundingBox (min, max);
@@ -681,7 +681,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBase<ContainerT, PointT>::incrementPointsInLOD (boost::uint64_t depth, boost::uint64_t new_point_count)
+    OutofcoreOctreeBase<ContainerT, PointT>::incrementPointsInLOD (std::uint64_t depth, std::uint64_t new_point_count)
     {
       if (std::numeric_limits<uint64_t>::max () - metadata_->getLODPoints (depth) < new_point_count)
       {
@@ -725,7 +725,7 @@ namespace pcl
 
     ////////////////////////////////////////////////////////////////////////////////    
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBase<ContainerT, PointT>::calculateDepth (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, const double leaf_resolution)
     {
       //Assume cube
@@ -734,7 +734,7 @@ namespace pcl
       if (side_length < leaf_resolution)
           return (0);
           
-      boost::uint64_t res = static_cast<boost::uint64_t> (std::ceil (std::log2 (side_length / leaf_resolution)));
+      std::uint64_t res = static_cast<std::uint64_t> (std::ceil (std::log2 (side_length / leaf_resolution)));
       
       PCL_DEBUG ("[pcl::outofcore::OutofcoreOctreeBase::calculateDepth] Setting depth to %d\n",res);
       return (res);
diff --git a/outofcore/include/pcl/outofcore/impl/octree_base_node.hpp b/outofcore/include/pcl/outofcore/impl/octree_base_node.hpp
index 777a782300c..fef7002cd7f 100644
--- a/outofcore/include/pcl/outofcore/impl/octree_base_node.hpp
+++ b/outofcore/include/pcl/outofcore/impl/octree_base_node.hpp
@@ -392,7 +392,7 @@ namespace pcl
         c[static_cast<size_t>(box)].push_back (&pt);
       }
       
-      boost::uint64_t points_added = 0;
+      std::uint64_t points_added = 0;
       for (size_t i = 0; i < 8; i++)
       {
         if (c[i].empty ())
@@ -407,7 +407,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::addDataToLeaf (const std::vector<const PointT*>& p, const bool skip_bb_check)
     {
       if (p.empty ())
@@ -479,7 +479,7 @@ namespace pcl
         c[box].push_back (p[i]);
       }
 
-      boost::uint64_t points_added = 0;
+      std::uint64_t points_added = 0;
       for (size_t i = 0; i < 8; i++)
       {
         if (c[i].empty ())
@@ -494,7 +494,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::addPointCloud (const typename pcl::PCLPointCloud2::Ptr& input_cloud, const bool skip_bb_check)
     {
       assert (this->root_node_->m_tree_ != NULL);
@@ -524,7 +524,7 @@ namespace pcl
           PCL_DEBUG ("[pcl::outofcore::OutofcoreOctreeBaseNode::%s] Computed %d indices in octact %d\n", __FUNCTION__, indices[k].size (), k);
         }
 
-        boost::uint64_t points_added = 0;
+        std::uint64_t points_added = 0;
 
         for(size_t i=0; i<8; i++)
         {
@@ -609,7 +609,7 @@ namespace pcl
     }
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::addDataAtMaxDepth (const AlignedPointTVector& p, const bool skip_bb_check)
     {
       assert (this->root_node_->m_tree_ != NULL);
@@ -646,7 +646,7 @@ namespace pcl
       return (buff.size ());
     }
     ////////////////////////////////////////////////////////////////////////////////
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::addDataAtMaxDepth (const pcl::PCLPointCloud2::Ptr input_cloud, const bool skip_bb_check)
     {
       //this assumes data is already in the correct bin
@@ -697,10 +697,10 @@ namespace pcl
     }
 
     ////////////////////////////////////////////////////////////////////////////////
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::addPointCloud_and_genLOD (const pcl::PCLPointCloud2::Ptr input_cloud) //, const bool skip_bb_check = false )
     {
-      boost::uint64_t points_added = 0;
+      std::uint64_t points_added = 0;
       
       if ( input_cloud->width * input_cloud->height == 0 )
       {
@@ -797,7 +797,7 @@ namespace pcl
     }
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::addDataToLeaf_and_genLOD (const AlignedPointTVector& p, const bool skip_bb_check)
     {
       // If there are no points return
@@ -835,7 +835,7 @@ namespace pcl
       std::vector<AlignedPointTVector> c;
       subdividePoints(p, c, skip_bb_check);
 
-      boost::uint64_t points_added = 0;
+      std::uint64_t points_added = 0;
       for(size_t i = 0; i < 8; i++)
       {
         // If child doesn't have points
@@ -1047,7 +1047,7 @@ namespace pcl
     }
 
     template<typename Container, typename PointT> void
-    OutofcoreOctreeBaseNode<Container, PointT>::queryFrustum (const double planes[24], std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check)
+    OutofcoreOctreeBaseNode<Container, PointT>::queryFrustum (const double planes[24], std::list<std::string>& file_names, const std::uint32_t query_depth, const bool skip_vfc_check)
     {
 
       enum {INSIDE, INTERSECT, OUTSIDE};
@@ -1196,7 +1196,7 @@ namespace pcl
 ////////////////////////////////////////////////////////////////////////////////
 
     template<typename Container, typename PointT> void
-    OutofcoreOctreeBaseNode<Container, PointT>::queryFrustum (const double planes[24], const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix, std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check)
+    OutofcoreOctreeBaseNode<Container, PointT>::queryFrustum (const double planes[24], const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix, std::list<std::string>& file_names, const std::uint32_t query_depth, const bool skip_vfc_check)
     {
 
       // If we're above our query depth
@@ -1331,7 +1331,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBaseNode<ContainerT, PointT>::queryBBIntersects (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, const boost::uint32_t query_depth, std::list<std::string>& file_names)
+    OutofcoreOctreeBaseNode<ContainerT, PointT>::queryBBIntersects (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, const std::uint32_t query_depth, std::list<std::string>& file_names)
     {
       
       Eigen::Vector3d my_min = min_bb;
@@ -1469,7 +1469,7 @@ namespace pcl
               assert ( tmp_blob->fields.size () == tmp_blob_within_bb->fields.size () );
               //concatenate those points into the returned dst_blob
               PCL_DEBUG ("[pcl::outofcore::OutofcoreOctreeBaseNode::%s] Concatenating point cloud in place\n", __FUNCTION__);
-              boost::uint64_t orig_points_in_destination = dst_blob->width*dst_blob->height;
+              std::uint64_t orig_points_in_destination = dst_blob->width*dst_blob->height;
               (void)orig_points_in_destination;
               int res = pcl::concatenate (*dst_blob, *tmp_blob_within_bb, *dst_blob);
               (void)res;
@@ -1561,7 +1561,7 @@ namespace pcl
     
     ////////////////////////////////////////////////////////////////////////////////
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBaseNode<ContainerT, PointT>::queryBBIncludes_subsample (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob, double percent)
+    OutofcoreOctreeBaseNode<ContainerT, PointT>::queryBBIncludes_subsample (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, std::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob, double percent)
     {
       if (intersectsWithBoundingBox (min_bb, max_bb))
         {
@@ -1629,7 +1629,7 @@ namespace pcl
     
     ////////////////////////////////////////////////////////////////////////////////
     template<typename ContainerT, typename PointT> void
-    OutofcoreOctreeBaseNode<ContainerT, PointT>::queryBBIncludes_subsample (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, boost::uint64_t query_depth, const double percent, AlignedPointTVector& dst)
+    OutofcoreOctreeBaseNode<ContainerT, PointT>::queryBBIncludes_subsample (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, std::uint64_t query_depth, const double percent, AlignedPointTVector& dst)
     {
       //check if the queried bounding box has any intersection with this node's bounding box
       if (intersectsWithBoundingBox (min_bb, max_bb))
@@ -1897,7 +1897,7 @@ namespace pcl
     }
 
     ////////////////////////////////////////////////////////////////////////////////
-    template<typename ContainerT, typename PointT> boost::uint64_t
+    template<typename ContainerT, typename PointT> std::uint64_t
     OutofcoreOctreeBaseNode<ContainerT, PointT>::getDataSize () const
     {
       return (this->payload_->getDataSize ());
@@ -2104,7 +2104,7 @@ namespace pcl
 
 //accelerate search
     template<typename ContainerT, typename PointT> void
-    queryBBIntersects_noload (const boost::filesystem::path& root_node, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::uint32_t query_depth, std::list<std::string>& bin_name)
+    queryBBIntersects_noload (const boost::filesystem::path& root_node, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const std::uint32_t query_depth, std::list<std::string>& bin_name)
     {
       OutofcoreOctreeBaseNode<ContainerT, PointT>* root = makenode_norec<ContainerT, PointT> (root_node, NULL);
       if (root == NULL)
@@ -2140,7 +2140,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename ContainerT, typename PointT> void
-    queryBBIntersects_noload (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::uint32_t query_depth, std::list<std::string>& bin_name)
+    queryBBIntersects_noload (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const std::uint32_t query_depth, std::list<std::string>& bin_name)
     {
       if (current->intersectsWithBoundingBox (min, max))
       {
diff --git a/outofcore/include/pcl/outofcore/impl/octree_disk_container.hpp b/outofcore/include/pcl/outofcore/impl/octree_disk_container.hpp
index 88e8b6a1d5b..66bf6eaed41 100644
--- a/outofcore/include/pcl/outofcore/impl/octree_disk_container.hpp
+++ b/outofcore/include/pcl/outofcore/impl/octree_disk_container.hpp
@@ -668,7 +668,7 @@ namespace pcl
     }
     ////////////////////////////////////////////////////////////////////////////////
 
-    template<typename PointT> boost::uint64_t
+    template<typename PointT> std::uint64_t
     OutofcoreOctreeDiskContainer<PointT>::getDataSize () const
     {
       pcl::PCLPointCloud2 cloud_info;
@@ -682,7 +682,7 @@ namespace pcl
       PCDReader reader;
       reader.readHeader (disk_storage_filename_, cloud_info, origin, orientation, pcd_version, data_type, data_index, 0);
       
-      boost::uint64_t total_points = cloud_info.width * cloud_info.height + writebuff_.size ();
+      std::uint64_t total_points = cloud_info.width * cloud_info.height + writebuff_.size ();
 
       return (total_points);
     }
diff --git a/outofcore/include/pcl/outofcore/impl/octree_ram_container.hpp b/outofcore/include/pcl/outofcore/impl/octree_ram_container.hpp
index ac09b41c5e6..8cae99cd221 100644
--- a/outofcore/include/pcl/outofcore/impl/octree_ram_container.hpp
+++ b/outofcore/include/pcl/outofcore/impl/octree_ram_container.hpp
@@ -63,8 +63,8 @@ namespace pcl
       {
         FILE* fxyz = fopen (path.string ().c_str (), "we");
 
-        boost::uint64_t num = size ();
-        for (boost::uint64_t i = 0; i < num; i++)
+        std::uint64_t num = size ();
+        for (std::uint64_t i = 0; i < num; i++)
         {
           const PointT& p = container_[i];
 
@@ -83,7 +83,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename PointT> void
-    OutofcoreOctreeRamContainer<PointT>::insertRange (const PointT* start, const boost::uint64_t count)
+    OutofcoreOctreeRamContainer<PointT>::insertRange (const PointT* start, const std::uint64_t count)
     {
       container_.insert (container_.end (), start, start + count);
     }
@@ -91,11 +91,11 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename PointT> void
-    OutofcoreOctreeRamContainer<PointT>::insertRange (const PointT* const * start, const boost::uint64_t count)
+    OutofcoreOctreeRamContainer<PointT>::insertRange (const PointT* const * start, const std::uint64_t count)
     {
       AlignedPointTVector temp;
       temp.resize (count);
-      for (boost::uint64_t i = 0; i < count; i++)
+      for (std::uint64_t i = 0; i < count; i++)
       {
         temp[i] = *start[i];
       }
@@ -105,7 +105,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename PointT> void
-    OutofcoreOctreeRamContainer<PointT>::readRange (const boost::uint64_t start, const boost::uint64_t count,
+    OutofcoreOctreeRamContainer<PointT>::readRange (const std::uint64_t start, const std::uint64_t count,
                                              AlignedPointTVector& v)
     {
       v.resize (count);
@@ -115,8 +115,8 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     template<typename PointT> void
-    OutofcoreOctreeRamContainer<PointT>::readRangeSubSample (const boost::uint64_t start, 
-                                                      const boost::uint64_t count,
+    OutofcoreOctreeRamContainer<PointT>::readRangeSubSample (const std::uint64_t start, 
+                                                      const std::uint64_t count,
                                                       const double percent, 
                                                       AlignedPointTVector& v)
     {
diff --git a/outofcore/include/pcl/outofcore/octree_base.h b/outofcore/include/pcl/outofcore/octree_base.h
index 2f09c6c53bc..670c47565e1 100644
--- a/outofcore/include/pcl/outofcore/octree_base.h
+++ b/outofcore/include/pcl/outofcore/octree_base.h
@@ -231,7 +231,7 @@ namespace pcl
          * \throws PCLException if the parent directory has existing children (detects an existing tree)
          * \throws PCLException if file extension is not ".oct_idx"
          */
-        OutofcoreOctreeBase (const boost::uint64_t max_depth, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::filesystem::path &root_node_name, const std::string &coord_sys);
+        OutofcoreOctreeBase (const std::uint64_t max_depth, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::filesystem::path &root_node_name, const std::string &coord_sys);
 
         virtual
         ~OutofcoreOctreeBase ();
@@ -241,7 +241,7 @@ namespace pcl
         /** \brief Recursively add points to the tree 
          *  \note shared read_write_mutex lock occurs
          */
-        boost::uint64_t
+        std::uint64_t
         addDataToLeaf (const AlignedPointTVector &p);
 
         /** \brief Copies the points from the point_cloud falling within the bounding box of the octree to the
@@ -250,7 +250,7 @@ namespace pcl
          *   PointT matches for each.
          *  \return Number of points successfully copied from the point cloud to the octree.
          */
-        boost::uint64_t
+        std::uint64_t
         addPointCloud (PointCloudConstPtr point_cloud);
 
         /** \brief Recursively copies points from input_cloud into the leaf nodes of the out-of-core octree, and stores them to disk.
@@ -259,7 +259,7 @@ namespace pcl
          * \param[in] skip_bb_check (default=false) whether to skip the bounding box check on insertion. Note the bounding box check is never skipped in the current implementation.
          * \return Number of poitns successfully copied from the point cloud to the octree
          */
-        boost::uint64_t
+        std::uint64_t
         addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check = false);
 
         /** \brief Recursively add points to the tree. 
@@ -279,20 +279,20 @@ namespace pcl
          * \return The total number of points added to the out-of-core
          * octree.
          */
-        boost::uint64_t
+        std::uint64_t
         addPointCloud_and_genLOD (pcl::PCLPointCloud2::Ptr &input_cloud);
 
-        boost::uint64_t
+        std::uint64_t
         addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud);
         
-        boost::uint64_t
+        std::uint64_t
         addPointCloud_and_genLOD (PointCloudConstPtr point_cloud);
 
         /** \brief Recursively add points to the tree subsampling LODs on the way.
          *
          * shared read_write_mutex lock occurs
          */
-        boost::uint64_t
+        std::uint64_t
         addDataToLeaf_and_genLOD (AlignedPointTVector &p);
 
         // Frustrum/Box/Region REQUESTS/QUERIES: DB Accessors
@@ -301,11 +301,11 @@ namespace pcl
         queryFrustum (const double *planes, std::list<std::string>& file_names) const;
 
 	      void
-        queryFrustum (const double *planes, std::list<std::string>& file_names, const boost::uint32_t query_depth) const;
+        queryFrustum (const double *planes, std::list<std::string>& file_names, const std::uint32_t query_depth) const;
 
 	      void
         queryFrustum (const double *planes, const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix,
-                      std::list<std::string>& file_names, const boost::uint32_t query_depth) const;
+                      std::list<std::string>& file_names, const std::uint32_t query_depth) const;
         
         //--------------------------------------------------------------------------------
         //templated PointT methods
@@ -320,7 +320,7 @@ namespace pcl
          * \param[out] bin_name List of paths to point data files (PCD currently) which satisfy the query
          */
         void
-        queryBBIntersects (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name) const;
+        queryBBIntersects (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const std::uint32_t query_depth, std::list<std::string> &bin_name) const;
 
         /** \brief Get Points in BB, only points inside BB. The query
          * processes the data at each node, filtering points that fall
@@ -334,7 +334,7 @@ namespace pcl
          * \param[out] dst The destination vector of points
          */
         void
-        queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint64_t query_depth, AlignedPointTVector &dst) const;
+        queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const std::uint64_t query_depth, AlignedPointTVector &dst) const;
 
         /** \brief Query all points falling within the input bounding box at \c query_depth and return a PCLPointCloud2 object in \c dst_blob.
          *
@@ -344,7 +344,7 @@ namespace pcl
          * \param[out] dst_blob Storage location for the points satisfying the query.
          **/
         void
-        queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob) const;
+        queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const std::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob) const;
         
         /** \brief Returns a random subsample of points within the given bounding box at \c query_depth.
          *
@@ -402,8 +402,8 @@ namespace pcl
          * \param[in] depth_index the level of detail at which we want the number of points (0 is root, 1, 2,...)
          * \return number of points in the tree at \b depth
          */
-        inline boost::uint64_t
-        getNumPointsAtDepth (const boost::uint64_t& depth_index) const
+        inline std::uint64_t
+        getNumPointsAtDepth (const std::uint64_t& depth_index) const
         {
           return (metadata_->getLODPoints (depth_index));
         }
@@ -416,14 +416,14 @@ namespace pcl
          *  \param[in] load_from_disk (default true) Whether to load PCD files to count exactly the number of points within the bounding box; setting this to false will return an upper bound by just reading the number of points from the PCD header, even if there may be some points in that node do not fall within the query bounding box.
          *  \return Number of points in the bounding box at depth \b query_depth
          **/
-        boost::uint64_t
+        std::uint64_t
         queryBoundingBoxNumPoints (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const int query_depth, bool load_from_disk = true);
         
 
         /** \brief Get number of points at each LOD 
          * \return vector of number of points in each LOD indexed by each level of depth, 0 to the depth of the tree.
          */
-        inline const std::vector<boost::uint64_t>&
+        inline const std::vector<std::uint64_t>&
         getNumPointsVector () const
         {
           return (metadata_->getLODPoints ());
@@ -431,13 +431,13 @@ namespace pcl
 
         /** \brief Get number of LODs, which is the height of the tree
          */
-        inline boost::uint64_t
+        inline std::uint64_t
         getDepth () const
         {
           return (metadata_->getDepth ());
         }
 
-        inline boost::uint64_t
+        inline std::uint64_t
         getTreeDepth () const
         {
           return (this->getDepth ());
@@ -453,7 +453,7 @@ namespace pcl
          *  \return the side length of the cubic voxel size at the specified depth
          */
         double
-        getVoxelSideLength (const boost::uint64_t& depth) const;
+        getVoxelSideLength (const std::uint64_t& depth) const;
 
         /** \brief Gets the smallest (assumed) cubic voxel side lengths. The smallest voxels are located at the max depth of the tree.
          * \return The side length of a the cubic voxel located at the leaves
@@ -569,7 +569,7 @@ namespace pcl
 	
       protected:
         void
-        init (const boost::uint64_t& depth, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::filesystem::path& root_name, const std::string& coord_sys);
+        init (const std::uint64_t& depth, const Eigen::Vector3d& min, const Eigen::Vector3d& max, const boost::filesystem::path& root_name, const std::string& coord_sys);
 
         OutofcoreOctreeBase (OutofcoreOctreeBase &rval);
 
@@ -602,7 +602,7 @@ namespace pcl
         /** \brief Increment current depths (LOD for branch nodes) point count; called by addDataAtMaxDepth in OutofcoreOctreeBaseNode
          */
         inline void
-        incrementPointsInLOD (boost::uint64_t depth, boost::uint64_t inc);
+        incrementPointsInLOD (std::uint64_t depth, std::uint64_t inc);
 
         /** \brief Auxiliary function to validate path_name extension is .octree
          *  
@@ -653,7 +653,7 @@ namespace pcl
         enlargeToCube (Eigen::Vector3d &bb_min, Eigen::Vector3d &bb_max);
 
         /** \brief Auxiliary function to compute the depth of the tree given the bounding box and the desired size of the leaf voxels */
-        boost::uint64_t
+        std::uint64_t
         calculateDepth (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb, const double leaf_resolution);
 
         double sample_percent_;
diff --git a/outofcore/include/pcl/outofcore/octree_base_node.h b/outofcore/include/pcl/outofcore/octree_base_node.h
index e9b760c1898..17ad9749e24 100644
--- a/outofcore/include/pcl/outofcore/octree_base_node.h
+++ b/outofcore/include/pcl/outofcore/octree_base_node.h
@@ -70,11 +70,11 @@ namespace pcl
 
     /** \brief Non-class method which performs a bounding box query without loading any of the point cloud data from disk */
     template<typename ContainerT, typename PointT> void
-    queryBBIntersects_noload (const boost::filesystem::path &root_node, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+    queryBBIntersects_noload (const boost::filesystem::path &root_node, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const std::uint32_t query_depth, std::list<std::string> &bin_name);
 
     /** \brief Non-class method overload */
     template<typename ContainerT, typename PointT> void
-    queryBBIntersects_noload (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d&, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+    queryBBIntersects_noload (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d&, const Eigen::Vector3d &max, const std::uint32_t query_depth, std::list<std::string> &bin_name);
 
     /** \class OutofcoreOctreeBaseNode 
      *
@@ -101,10 +101,10 @@ namespace pcl
       makenode_norec<ContainerT, PointT> (const boost::filesystem::path &path, OutofcoreOctreeBaseNode<ContainerT, PointT>* super);
   
       friend void
-      queryBBIntersects_noload<ContainerT, PointT> (const boost::filesystem::path &rootnode, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+      queryBBIntersects_noload<ContainerT, PointT> (const boost::filesystem::path &rootnode, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const std::uint32_t query_depth, std::list<std::string> &bin_name);
 
       friend void
-      queryBBIntersects_noload<ContainerT, PointT> (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+      queryBBIntersects_noload<ContainerT, PointT> (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const std::uint32_t query_depth, std::list<std::string> &bin_name);
   
       public:
         using octree_disk = OutofcoreOctreeBase<OutofcoreOctreeDiskContainer < PointT > , PointT >;
@@ -159,10 +159,10 @@ namespace pcl
         queryFrustum (const double planes[24], std::list<std::string>& file_names);
 
         void
-        queryFrustum (const double planes[24], std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check = false);
+        queryFrustum (const double planes[24], std::list<std::string>& file_names, const std::uint32_t query_depth, const bool skip_vfc_check = false);
 
         void
-        queryFrustum (const double planes[24], const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix, std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check = false);
+        queryFrustum (const double planes[24], const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix, std::list<std::string>& file_names, const std::uint32_t query_depth, const bool skip_vfc_check = false);
 
         //point extraction
         /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth 
@@ -194,15 +194,15 @@ namespace pcl
          *  \param[out] v std::list of points returned by the query
          */
         virtual void
-        queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, boost::uint64_t query_depth, const double percent, AlignedPointTVector &v);
+        queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, std::uint64_t query_depth, const double percent, AlignedPointTVector &v);
 
         virtual void
-        queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob, double percent = 1.0);
+        queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, std::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob, double percent = 1.0);
 
         /** \brief Recursive acquires PCD paths to any node with which the queried bounding box intersects (at query_depth only).
          */
         virtual void
-        queryBBIntersects (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const boost::uint32_t query_depth, std::list<std::string> &file_names);
+        queryBBIntersects (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const std::uint32_t query_depth, std::list<std::string> &file_names);
 
         /** \brief Write the voxel size to stdout at \c query_depth 
          * \param[in] query_depth The depth at which to print the size of the voxel/bounding boxes
@@ -214,10 +214,10 @@ namespace pcl
          *  \param[in] p vector of points to add to the leaf
          *  \param[in] skip_bb_check whether to check if the point's coordinates fall within the bounding box
          */
-        virtual boost::uint64_t
+        virtual std::uint64_t
         addDataToLeaf (const AlignedPointTVector &p, const bool skip_bb_check = true);
 
-        virtual boost::uint64_t
+        virtual std::uint64_t
         addDataToLeaf (const std::vector<const PointT*> &p, const bool skip_bb_check = true);
 
         /** \brief Add a single PCLPointCloud2 object into the octree.
@@ -225,11 +225,11 @@ namespace pcl
          * \param[in] input_cloud
          * \param[in] skip_bb_check (default = false)
          */
-        virtual boost::uint64_t
+        virtual std::uint64_t
         addPointCloud (const pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check = false);
 
         /** \brief Add a single PCLPointCloud2 into the octree and build the subsampled LOD during construction; this method of LOD construction is <b>not</b> multiresolution. Rather, there are no redundant data. */
-        virtual boost::uint64_t
+        virtual std::uint64_t
         addPointCloud_and_genLOD (const pcl::PCLPointCloud2::Ptr input_cloud); //, const bool skip_bb_check);
         
         /** \brief Recursively add points to the leaf and children subsampling LODs
@@ -237,7 +237,7 @@ namespace pcl
          *
          * \note rng_mutex_ lock occurs
          */
-        virtual boost::uint64_t
+        virtual std::uint64_t
         addDataToLeaf_and_genLOD (const AlignedPointTVector &p, const bool skip_bb_check);
 
         /** \brief Write a python visual script to @b file
@@ -295,7 +295,7 @@ namespace pcl
         getChildPtr (size_t index_arg) const;
 
         /** \brief Gets the number of points available in the PCD file */
-        virtual boost::uint64_t
+        virtual std::uint64_t
         getDataSize () const;
 
         inline virtual void
@@ -383,7 +383,7 @@ namespace pcl
          *  points that fall into the bounding box to this node 
          *  \return number of points successfully added
          */
-        boost::uint64_t
+        std::uint64_t
         addDataAtMaxDepth (const AlignedPointTVector &p, const bool skip_bb_check = true);
 
         /** \brief Add data to the leaf when at max depth of tree. If
@@ -398,7 +398,7 @@ namespace pcl
          *  points that fall into the bounding box to this node 
          *  \return number of points successfully added
          */
-        boost::uint64_t
+        std::uint64_t
         addDataAtMaxDepth (const pcl::PCLPointCloud2::Ptr input_cloud, const bool skip_bb_check = true);
         
         /** \brief Tests whether the input bounding box intersects with the current node's bounding box 
@@ -463,7 +463,7 @@ namespace pcl
         recFreeChildren ();
 
         /** \brief Number of points in the payload */
-        inline boost::uint64_t
+        inline std::uint64_t
         size () const
         {
           return (payload_->size ());
diff --git a/outofcore/include/pcl/outofcore/octree_disk_container.h b/outofcore/include/pcl/outofcore/octree_disk_container.h
index 19aaf457474..43bd36236f0 100644
--- a/outofcore/include/pcl/outofcore/octree_disk_container.h
+++ b/outofcore/include/pcl/outofcore/octree_disk_container.h
@@ -268,7 +268,7 @@ namespace pcl
         getRandomUUIDString (std::string &s);
 
         /** \brief Returns the number of points in the PCD file by reading the PCD header. */
-        boost::uint64_t
+        std::uint64_t
         getDataSize () const;
         
       private:
diff --git a/outofcore/include/pcl/outofcore/outofcore_base_data.h b/outofcore/include/pcl/outofcore/outofcore_base_data.h
index 8d7420a6ac5..a8d04a63628 100644
--- a/outofcore/include/pcl/outofcore/outofcore_base_data.h
+++ b/outofcore/include/pcl/outofcore/outofcore_base_data.h
@@ -150,20 +150,20 @@ namespace pcl
         virtual void
         setPointType (const std::string& point_type_arg);
 
-        virtual std::vector<boost::uint64_t>&
+        virtual std::vector<std::uint64_t>&
         getLODPoints ();
-        virtual std::vector<boost::uint64_t>
+        virtual std::vector<std::uint64_t>
         getLODPoints () const;
         /** \brief Get the number of points at the given depth */
-        virtual boost::uint64_t
-        getLODPoints (const boost::uint64_t& depth_index) const;
+        virtual std::uint64_t
+        getLODPoints (const std::uint64_t& depth_index) const;
         
         /** \brief Initialize the LOD vector with points all 0 */
         virtual void
-        setLODPoints (const boost::uint64_t& depth);
+        setLODPoints (const std::uint64_t& depth);
         /** \brief Copy a vector of LOD points into this metadata (dangerous!)*/
         virtual void
-        setLODPoints (std::vector<boost::uint64_t>& lod_points_arg);
+        setLODPoints (std::vector<std::uint64_t>& lod_points_arg);
 
         /** \brief Set the number of points at lod_index_arg manually 
          *  \param[in] lod_index_arg the depth at which this increments the number of LOD points
@@ -171,7 +171,7 @@ namespace pcl
          *  \param[in] increment If true, increments the number of points at the LOD rather than overwriting the number of points
          */
         virtual void
-        setLODPoints (const boost::uint64_t& lod_index_arg, const boost::uint64_t& num_points_arg, const bool increment=true);
+        setLODPoints (const std::uint64_t& lod_index_arg, const std::uint64_t& num_points_arg, const bool increment=true);
         
         /** \brief Set information about the coordinate system */
         virtual void
@@ -182,8 +182,8 @@ namespace pcl
 
         /** \brief Set the depth of the tree corresponding to JSON "lod:number". This should always be equal to LOD_num_points_.size()-1 */
         virtual void
-        setDepth (const boost::uint64_t& depth_arg);
-        virtual boost::uint64_t
+        setDepth (const std::uint64_t& depth_arg);
+        virtual std::uint64_t
         getDepth () const;
 
         /** \brief Provide operator overload to stream ascii file data*/
@@ -209,10 +209,10 @@ namespace pcl
         std::string point_type_;
         
         /** \brief Depth of the tree (which is the number of levels of depth); maps to JSON "lod":int*/
-        boost::uint64_t levels_of_depth_;
+        std::uint64_t levels_of_depth_;
         
         /** \brief Vector of number of points at each LOD. For a tree with no LOD, all fields will be zero except for the field indexed by LOD_points_[levels_of_depth]; maps to JSON "numpts":int array*/
-        std::vector<boost::uint64_t> LOD_num_points_;
+        std::vector<std::uint64_t> LOD_num_points_;
 
         /** \brief Writes the JSON metadata to a string */
         void
diff --git a/outofcore/src/outofcore_base_data.cpp b/outofcore/src/outofcore_base_data.cpp
index d7b99012234..608a8c5bcaa 100644
--- a/outofcore/src/outofcore_base_data.cpp
+++ b/outofcore/src/outofcore_base_data.cpp
@@ -172,7 +172,7 @@ namespace pcl
     {
       // Open JSON
       std::vector<char> idx_input;
-      boost::uintmax_t len = boost::filesystem::file_size (metadata_filename_);
+      std::uintmax_t len = boost::filesystem::file_size (metadata_filename_);
       idx_input.resize (len + 1);
 
       std::ifstream f (metadata_filename_.string ().c_str (), std::ios::in);
@@ -224,7 +224,7 @@ namespace pcl
       for (int i = 0; i < (lod->valueint + 1); i++)
       {
         //cJSON doesn't have explicit 64bit int, have to use double, get up to 2^52
-        LOD_num_points_[i] = static_cast<boost::uint64_t> (cJSON_GetArrayItem (numpts, i)->valuedouble );
+        LOD_num_points_[i] = static_cast<std::uint64_t> (cJSON_GetArrayItem (numpts, i)->valuedouble );
       }
       levels_of_depth_ = lod->valueint;
       coordinate_system_ = coord->valuestring;
@@ -276,7 +276,7 @@ namespace pcl
   
     ////////////////////////////////////////////////////////////////////////////////
 
-    std::vector<boost::uint64_t>&
+    std::vector<std::uint64_t>&
     OutofcoreOctreeBaseMetadata::getLODPoints ()
     {
       return (LOD_num_points_);
@@ -284,7 +284,7 @@ namespace pcl
     
     ////////////////////////////////////////////////////////////////////////////////
 
-    std::vector<boost::uint64_t>
+    std::vector<std::uint64_t>
     OutofcoreOctreeBaseMetadata::getLODPoints () const
     {
       return (LOD_num_points_);
@@ -292,8 +292,8 @@ namespace pcl
 
     ////////////////////////////////////////////////////////////////////////////////
 
-    boost::uint64_t
-    OutofcoreOctreeBaseMetadata::getLODPoints (const boost::uint64_t& depth_index) const
+    std::uint64_t
+    OutofcoreOctreeBaseMetadata::getLODPoints (const std::uint64_t& depth_index) const
     {
       return (LOD_num_points_[depth_index]);
     }
@@ -301,7 +301,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     void
-    OutofcoreOctreeBaseMetadata::setLODPoints (const boost::uint64_t& depth)
+    OutofcoreOctreeBaseMetadata::setLODPoints (const std::uint64_t& depth)
     {
       LOD_num_points_.clear ();
       LOD_num_points_.resize (depth);
@@ -311,7 +311,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     void
-    OutofcoreOctreeBaseMetadata::setLODPoints (std::vector<boost::uint64_t>& lod_points_arg)
+    OutofcoreOctreeBaseMetadata::setLODPoints (std::vector<std::uint64_t>& lod_points_arg)
     {
       assert (this->LOD_num_points_.size () == lod_points_arg.size ());
       
@@ -321,7 +321,7 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     void
-    OutofcoreOctreeBaseMetadata::setLODPoints (const boost::uint64_t& lod_index_arg, const boost::uint64_t& num_points_arg, const bool increment)
+    OutofcoreOctreeBaseMetadata::setLODPoints (const std::uint64_t& lod_index_arg, const std::uint64_t& num_points_arg, const bool increment)
     {
       assert (lod_index_arg < LOD_num_points_.size ());
 
@@ -350,12 +350,12 @@ namespace pcl
     ////////////////////////////////////////////////////////////////////////////////
 
     void
-    OutofcoreOctreeBaseMetadata::setDepth (const boost::uint64_t& depth_arg)
+    OutofcoreOctreeBaseMetadata::setDepth (const std::uint64_t& depth_arg)
     {
       this->levels_of_depth_ = depth_arg;
     }
     
-    boost::uint64_t
+    std::uint64_t
     OutofcoreOctreeBaseMetadata::getDepth () const
     {
       return (levels_of_depth_);
diff --git a/outofcore/src/outofcore_node_data.cpp b/outofcore/src/outofcore_node_data.cpp
index e96990b9616..39f3c507958 100644
--- a/outofcore/src/outofcore_node_data.cpp
+++ b/outofcore/src/outofcore_node_data.cpp
@@ -268,7 +268,7 @@ namespace pcl
 
       //load CJSON
       std::vector<char> idx_input;
-      boost::uintmax_t len = boost::filesystem::file_size (metadata_filename_);
+      std::uintmax_t len = boost::filesystem::file_size (metadata_filename_);
       idx_input.resize (len + 1);
       
       std::ifstream f (metadata_filename_.string ().c_str (), std::ios::in);
diff --git a/outofcore/tools/outofcore_print.cpp b/outofcore/tools/outofcore_print.cpp
index 340b189e248..f9556396c2d 100644
--- a/outofcore/tools/outofcore_print.cpp
+++ b/outofcore/tools/outofcore_print.cpp
@@ -119,9 +119,9 @@ outofcorePrint (boost::filesystem::path tree_root, size_t print_depth, bool boun
     print_depth = depth;
 
   // Cloud point counts at each level
-  std::vector<boost::uint64_t> lodPoints = octree->getNumPointsVector ();
+  std::vector<std::uint64_t> lodPoints = octree->getNumPointsVector ();
   PCL_INFO (" Points:\n");
-  for (boost::uint64_t i = 0; i < lodPoints.size (); i++)
+  for (std::uint64_t i = 0; i < lodPoints.size (); i++)
     PCL_INFO ("   %d: %d\n", i, lodPoints[i]);
 
   // Cloud voxel side length
@@ -133,8 +133,8 @@ outofcorePrint (boost::filesystem::path tree_root, size_t print_depth, bool boun
   PCL_INFO(" Voxel Count: %d\n", voxel_centers.size ());
 
   // Point data for statistics
-  std::vector<boost::uint64_t> pointsPerVoxel;
-	ba::accumulator_set<boost::uint64_t, ba::features< ba::tag::min,  ba::tag::max, ba::tag::mean,  ba::tag::variance> > acc;
+  std::vector<std::uint64_t> pointsPerVoxel;
+	ba::accumulator_set<std::uint64_t, ba::features< ba::tag::min,  ba::tag::max, ba::tag::mean,  ba::tag::variance> > acc;
 
   if (!breadth_first)
   {
diff --git a/outofcore/tools/outofcore_process.cpp b/outofcore/tools/outofcore_process.cpp
index 6d88fc99940..8b032e6b2f2 100644
--- a/outofcore/tools/outofcore_process.cpp
+++ b/outofcore/tools/outofcore_process.cpp
@@ -184,7 +184,7 @@ outofcoreProcess (std::vector<boost::filesystem::path> pcd_paths, boost::filesys
 
     PCLPointCloud2::Ptr cloud = getCloudFromFile (pcd_path);
 
-    boost::uint64_t pts = 0;
+    std::uint64_t pts = 0;
     
     if (gen_lod && !multiresolution)
     {
diff --git a/test/outofcore/test_outofcore.cpp b/test/outofcore/test_outofcore.cpp
index ef879c1ab61..21274cb9540 100644
--- a/test/outofcore/test_outofcore.cpp
+++ b/test/outofcore/test_outofcore.cpp
@@ -705,7 +705,7 @@ TEST_F (OutofcoreTest, PointCloud2_Constructors)
   const Eigen::Vector3d min (-100.1, -100.1, -100.1);
   const Eigen::Vector3d max (100.1, 100.1, 100.1);
   
-  const boost::uint64_t depth = 2;
+  const std::uint64_t depth = 2;
   
   //create a point cloud
   pcl::PointCloud<PointT>::Ptr test_cloud (new pcl::PointCloud<PointT> ());
@@ -836,7 +836,7 @@ TEST_F (OutofcoreTest, PointCloud2_QueryBoundingBox)
   const Eigen::Vector3d min (-100.1, -100.1, -100.1);
   const Eigen::Vector3d max (100.1, 100.1, 100.1);
   
-  const boost::uint64_t depth = 2;
+  const std::uint64_t depth = 2;
 
   //create a point cloud
   pcl::PointCloud<PointT>::Ptr test_cloud (new pcl::PointCloud<PointT> ());
@@ -888,7 +888,7 @@ TEST_F (OutofcoreTest, PointCloud2_Query)
   const Eigen::Vector3d min (-100.1, -100.1, -100.1);
   const Eigen::Vector3d max (100.1, 100.1, 100.1);
   
-  const boost::uint64_t depth = 2;
+  const std::uint64_t depth = 2;
   
   //create a point cloud
   pcl::PointCloud<PointT>::Ptr test_cloud (new pcl::PointCloud<PointT> ());
@@ -929,7 +929,7 @@ TEST_F (OutofcoreTest, PointCloud2_Query)
 
   uint64_t total_octreeB_LOD_query = 0;
   
-  for (boost::uint64_t i=0; i <= octreeB.getDepth (); i++)
+  for (std::uint64_t i=0; i <= octreeB.getDepth (); i++)
   {
     octreeB.queryBBIncludes (min, max, i, query_result_b);
     total_octreeB_LOD_query += query_result_b->width*query_result_b->height;