strip_reader.hpp

Go to the documentation of this file.

//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// libpniio 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libpniio.  If not, see <http://www.gnu.org/licenses/>.
// ===========================================================================
//
// Created on: Jun 22, 2011
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
//
#pragma once

#include <iostream>
#include <fstream>
#include <vector>

#include "ifd.hpp"
#include "../image_info.hpp"

#include <pni/core/types.hpp>
#include <pni/core/arrays.hpp>


namespace pni {
namespace io {
namespace tiff {    

    class strip_reader 
    {
        private:
            std::vector<size_t> _offsets;   
            std::vector<size_t> _byte_cnts; 
            std::vector<size_t> _bits_per_channel; 
            std::vector<pni::core::type_id_t> _channel_types; 

            //-----------------------------------------------------------------
            template<
                     typename IT,
                     typename CTYPE
                    > 
            void _read_interlace(size_t c,std::ifstream &stream,
                                 CTYPE &data) const;

        public:
            //====================constructors and destructor==================
            strip_reader();

            //-----------------------------------------------------------------
            strip_reader(const strip_reader &r);

            //-----------------------------------------------------------------
            strip_reader(strip_reader &&r);

            //-----------------------------------------------------------------
            strip_reader(const std::vector<size_t> &offsets,
                         const std::vector<size_t> &byte_counts,
                         const std::vector<size_t> &bits_per_channel,
                         const std::vector<pni::core::type_id_t> &channel_types);

            //------------------------------------------------------------------
            ~strip_reader();

            //====================assignemnt operators==========================
            strip_reader &operator=(const strip_reader &r);

            //------------------------------------------------------------------
            strip_reader &operator=(strip_reader &&r);

            //===========static public member functions=========================
            static strip_reader create(std::ifstream &stream,
                                       const ifd &image_dir,
                                       const image_info &info);

            //=====================public member methods========================
            template<typename CTYPE> 
                void read(size_t c,std::ifstream &stream,CTYPE &data) 
            {
                using namespace pni::core;
                //first we need to determine the datatype of the

                if(this->_channel_types[c] == type_id_t::UINT8)
                    this->_read_interlace<uint8>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::INT8)
                    this->_read_interlace<int8>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::UINT16)
                    this->_read_interlace<uint16>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::INT16)
                    this->_read_interlace<int16>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::UINT32)
                    this->_read_interlace<uint32>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::INT32)
                    this->_read_interlace<int32>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::UINT64)
                    this->_read_interlace<uint64>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::INT64)
                    this->_read_interlace<int64>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::FLOAT32)
                    this->_read_interlace<float32>(c,stream,data);
                else if(this->_channel_types[c] == type_id_t::FLOAT64)
                    this->_read_interlace<float64>(c,stream,data);
                else
                    throw type_error(EXCEPTION_RECORD,
                          "StripReader cannot handle channel type!");
            }

            //=====================output operator==============================
            friend std::ostream &operator<<(std::ostream &o,
                                            const strip_reader &r);
        };

    //-------------------------------------------------------------------------
    template<typename IT,typename CTYPE> 
        void strip_reader::_read_interlace(size_t channel,
                std::ifstream &stream,CTYPE &data) const
    {
        typedef typename CTYPE::value_type value_type;
        //compute the size of a pixel in bytes
        size_t pixel_size = std::accumulate(_bits_per_channel.begin(),
                                            _bits_per_channel.end(),0)/8;
       
        //compute the offset from the begining of a pixel to the requested
        //sample. The offset is given in bytes
        size_t sample_offset = std::accumulate(_bits_per_channel.begin(),
                                               _bits_per_channel.begin()+channel,
                                               0)/8;

        //size of the sample type
        size_t sample_size = sizeof(IT);

        IT sample_buffer; 

        typename CTYPE::iterator piter = data.begin(); //pixel iterator
        while(piter != data.end())
        {
            //loop over all strips
            for(size_t strip=0;strip<_offsets.size();strip++)
            {
                size_t npixels = _byte_cnts[strip]/pixel_size;

                //set the stream to the offset of the actual strip
                stream.seekg(_offsets[strip]+sample_offset,std::ios::beg);

                //loop over all pixels in the strip
                for(size_t i=0;i<npixels; ++i)
                {
                    stream.read(reinterpret_cast<char*>(&sample_buffer),sample_size);
                    stream.seekg(pixel_size-sample_size,std::ios::cur);
                    *piter++ = value_type(sample_buffer);
                }
            }
        }
    }


//end of namespace
}
}
}