serialization.h

// This file is part of snark, a generic and flexible library
// for robotics research.
//
// Copyright (C) 2011 The University of Sydney
//
// snark is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// snark is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
// for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with snark. If not, see <http://www.gnu.org/licenses/>.

#ifndef SNARK_IMAGING_CVMAT_SERIALIZATION_H_
#define SNARK_IMAGING_CVMAT_SERIALIZATION_H_

#include <iostream>
#include <string>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opencv2/core/core.hpp>
#include <comma/base/types.h>
#include <comma/csv/binary.h>
#include <comma/visiting/traits.h>


namespace snark{ namespace cv_mat {

class serialization
{
    public:
        struct header
        {
            boost::posix_time::ptime timestamp;
            comma::uint32 rows;
            comma::uint32 cols;
            comma::uint32 type; 
            comma::uint32 size; 
            
            header();
            header( const cv::Mat& m );
            header( const std::pair< boost::posix_time::ptime, cv::Mat >& p ); 
        };
        
        struct options
        {
            std::string fields;
            comma::uint32 rows;
            comma::uint32 cols;
            std::string type;
            bool no_header;
            bool header_only;
            
            options() : no_header( false ), header_only( false ) {}
            header get_header() const; 
            static std::string usage();
            static std::string type_usage();
        };

        serialization();

        serialization( const std::string& fields, const comma::csv::format& format, bool headerOnly = false, const header& default_header = header() );
        
        serialization( const options& options );

        std::size_t put( const std::pair< boost::posix_time::ptime, cv::Mat >& m, char* buf ) const;

        std::size_t get( std::pair< boost::posix_time::ptime, cv::Mat >& m, const char* buf ) const;

        std::pair< boost::posix_time::ptime, cv::Mat > get( const char* buf ) const;
        
        header get_header( const char* buf ) const;

        static const std::string& usage();

        std::size_t size( const cv::Mat& m ) const;

        std::size_t size( const std::pair< boost::posix_time::ptime, cv::Mat >& m ) const;

        std::pair< boost::posix_time::ptime, cv::Mat > read( std::istream& is );

        void write( std::ostream& os, const std::pair< boost::posix_time::ptime, cv::Mat >& m );

    private:
        boost::scoped_ptr< comma::csv::binary< header > > m_binary;
        std::vector< char > m_buffer;
        bool m_headerOnly;
        header m_header; 
};

} }  // namespace snark{ namespace cv_mat {
    
namespace comma { namespace visiting {

template <> struct traits< snark::cv_mat::serialization::header >
{
    template < typename K, typename V >
    static void visit( const K&, snark::cv_mat::serialization::header& h, V& v )
    {
        v.apply( "t", h.timestamp );
        v.apply( "rows", h.rows );
        v.apply( "cols", h.cols );
        v.apply( "type", h.type );
        v.apply( "size", h.size );
    }

    template < typename K, typename V >
    static void visit( const K&, const snark::cv_mat::serialization::header& h, V& v )
    {
        v.apply( "t", h.timestamp );
        v.apply( "rows", h.rows );
        v.apply( "cols", h.cols );
        v.apply( "type", h.type );
        v.apply( "size", h.size );
    }
};

template <> struct traits< snark::cv_mat::serialization::options >
{
    template < typename K, typename V >
    static void visit( const K&, snark::cv_mat::serialization::options& h, V& v )
    {
        v.apply( "fields", h.fields );
        v.apply( "rows", h.rows );
        v.apply( "cols", h.cols );
        v.apply( "type", h.type );
        v.apply( "no-header", h.no_header );
        v.apply( "header-only", h.header_only );
    }

    template < typename K, typename V >
    static void visit( const K&, const snark::cv_mat::serialization::options& h, V& v )
    {
        v.apply( "fields", h.fields );
        v.apply( "rows", h.rows );
        v.apply( "cols", h.cols );
        v.apply( "type", h.type );
        v.apply( "no-header", h.no_header );
        v.apply( "header-only", h.header_only );
    }
};
    
} } // namespace comma { namespace visiting {

#endif // SNARK_IMAGING_CVMAT_SERIALIZATION_H_