octree_disk_container.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2010-2012, Willow Garage, Inc.
 *  Copyright (c) 2012, Urban Robotics, Inc.
 *
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of Willow Garage, Inc. nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  $Id: octree_disk_container.h 6927M 2012-08-24 13:26:40Z (local) $
 */

#ifndef PCL_OUTOFCORE_OCTREE_DISK_CONTAINER_H_
#define PCL_OUTOFCORE_OCTREE_DISK_CONTAINER_H_

// C++
#include <vector>
#include <string>

#include <pcl/outofcore/boost.h>
#include <pcl/outofcore/octree_abstract_node_container.h>
#include <pcl/io/pcd_io.h>
#include <pcl/PCLPointCloud2.h>

//allows operation on POSIX
#if !defined WIN32
#define _fseeki64 fseeko
#elif defined __MINGW32__
#define _fseeki64 fseeko64
#endif

namespace pcl
{
  namespace outofcore
  {
    template<typename PointT = pcl::PointXYZ>
    class OutofcoreOctreeDiskContainer : public OutofcoreAbstractNodeContainer<PointT>
    {
  
      public:
        typedef typename OutofcoreAbstractNodeContainer<PointT>::AlignedPointTVector AlignedPointTVector;
        
        OutofcoreOctreeDiskContainer ();

        OutofcoreOctreeDiskContainer (const boost::filesystem::path &dir);

        ~OutofcoreOctreeDiskContainer ();

        inline PointT
        operator[] (uint64_t idx) const;

        inline void
        push_back (const PointT& p);

        void
        insertRange (const AlignedPointTVector& src);

        void
        insertRange (const pcl::PCLPointCloud2::Ptr &input_cloud);

        void
        insertRange (const PointT* const * start, const uint64_t count);
    
        void
        insertRange (const PointT* start, const uint64_t count);

        void
        readRange (const uint64_t start, const uint64_t count, AlignedPointTVector &dst);

        void
        readRange (const uint64_t, const uint64_t, pcl::PCLPointCloud2::Ptr &dst);

        int
        read (pcl::PCLPointCloud2::Ptr &output_cloud);

        void
        readRangeSubSample (const uint64_t start, const uint64_t count, const double percent,
                            AlignedPointTVector &dst);

        void
        readRangeSubSample_bernoulli (const uint64_t start, const uint64_t count, 
                                      const double percent, AlignedPointTVector& dst);

        uint64_t
        size () const
        {
          return (filelen_ + writebuff_.size ());
        }

        inline bool
        empty () const
        {
          return ((filelen_ == 0) && writebuff_.empty ());
        }

        void
        flush (const bool force_cache_dealloc)
        {
          flushWritebuff (force_cache_dealloc);
        }

        inline std::string&
        path ()
        {
          return (*disk_storage_filename_);
        }

        inline void
        clear ()
        {
          //clear elements that have not yet been written to disk
          writebuff_.clear ();
          //remove the binary data in the directory
          PCL_DEBUG ("[Octree Disk Container] Removing the point data from disk, in file %s\n",disk_storage_filename_->c_str ());
          boost::filesystem::remove (boost::filesystem::path (disk_storage_filename_->c_str ()));
          //reset the size-of-file counter
          filelen_ = 0;
        }

        void
        convertToXYZ (const boost::filesystem::path &path)
        {
          if (boost::filesystem::exists (*disk_storage_filename_))
          {
            FILE* fxyz = fopen (path.string ().c_str (), "w");

            FILE* f = fopen (disk_storage_filename_->c_str (), "rb");
            assert (f != NULL);

            uint64_t num = size ();
            PointT p;
            char* loc = reinterpret_cast<char*> ( &p );

            for (uint64_t i = 0; i < num; i++)
            {
              int seekret = _fseeki64 (f, i * sizeof (PointT), SEEK_SET);
              (void)seekret;
              assert (seekret == 0);
              size_t readlen = fread (loc, sizeof (PointT), 1, f);
              (void)readlen;
              assert (readlen == 1);

              //of << p.x << "\t" << p.y << "\t" << p.z << "\n";
              std::stringstream ss;
              ss << std::fixed;
              ss.precision (16);
              ss << p.x << "\t" << p.y << "\t" << p.z << "\n";

              fwrite (ss.str ().c_str (), 1, ss.str ().size (), fxyz);
            }
            int res = fclose (f);
            (void)res;
            assert (res == 0);
            res = fclose (fxyz);
            assert (res == 0);
          }
        }

        static void
        getRandomUUIDString (std::string &s);

        boost::uint64_t
        getDataSize () const;
        
      private:
        //no copy construction
        OutofcoreOctreeDiskContainer (const OutofcoreOctreeDiskContainer &rval) { }


        OutofcoreOctreeDiskContainer&
        operator= (const OutofcoreOctreeDiskContainer &rval) { }

        void
        flushWritebuff (const bool force_cache_dealloc);
    
        boost::shared_ptr<std::string> disk_storage_filename_;

        //--- possibly deprecated parameter variables --//

        //number of elements in file
        uint64_t filelen_;

        AlignedPointTVector writebuff_;

        const static uint64_t READ_BLOCK_SIZE_;

        static const uint64_t WRITE_BUFF_MAX_;

        static boost::mutex rng_mutex_;
        static boost::mt19937 rand_gen_;
        static boost::uuids::random_generator uuid_gen_;

    };
  } //namespace outofcore
} //namespace pcl

#endif //PCL_OUTOFCORE_OCTREE_DISK_CONTAINER_H_