tiff_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 15, 2011
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
//
#pragma once

#include<iostream>
#include<vector>
#include<boost/current_function.hpp>

#include "../image_reader.hpp"
#include "../image_info.hpp"
#include "ifd.hpp"
#include "ifd_entry.hpp"
#include "strip_reader.hpp"


namespace pni{
namespace io{    

    class tiff_reader:public image_reader 
    {
        private:
            bool _little_endian;  
            std::vector<tiff::ifd> _ifds; 
          
            //=====================private methods=============================
            static bool _is_little_endian(std::ifstream &stream);

            //-----------------------------------------------------------------
            static void _check_if_tiff(std::ifstream &stream);

            //------------------------------------------------------------------
            static int32 _read_ifd_offset(std::ifstream &stream);

            //-----------------------------------------------------------------
            static size_t _read_ifd_size(std::ifstream &stream);

            //-----------------------------------------------------------------
            static std::vector<size_t> 
                _get_bits_per_sample(std::ifstream &stream,const tiff::ifd &ifd);

            //-----------------------------------------------------------------
            static std::vector<size_t> 
                _get_sample_format(std::ifstream &stream,const tiff::ifd &ifd);

            //-----------------------------------------------------------------
            static type_id_t _get_type_id(size_t bps,size_t sf);
           
            //-----------------------------------------------------------------
            void _read_ifds(); 

            //----------------------------------------------------------------
            template<typename CTYPE> 
            void _read_data(size_t i,size_t c,CTYPE &data);
        public:
            //==============constructors and destructor========================
            tiff_reader();

            //-----------------------------------------------------------------
            tiff_reader(tiff_reader &&r);

            //-----------------------------------------------------------------
            explicit tiff_reader(const pni::core::string &fname);

            //-----------------------------------------------------------------
            tiff_reader(const tiff_reader &) = delete;

            //-----------------------------------------------------------------
            ~tiff_reader();

            //======================assignment operators=======================
            tiff_reader &operator=(tiff_reader &&r);

            //--------------------------------------------------------------
            tiff_reader &operator=(const tiff_reader &r) = delete;

            //=====================class methods===========================
            virtual size_t nimages() const;

            //-----------------------------------------------------------------
            virtual image_info info(size_t i) const;

            //-----------------------------------------------------------------
            virtual void open();

            //-----------------------------------------------------------------
            virtual void close();

            //-----------------------------------------------------------------
            template<typename CTYPE> CTYPE image(size_t i,size_t c=0) 
            {
                using namespace pni::core;
                image_info info = this->info(i);
                CTYPE data;
                try { data = CTYPE(info.npixels()); }
                catch(...)
                {
                    throw memory_allocation_error(EXCEPTION_RECORD,
                            "Allocation of image data container failed!");
                }

                //here we read the data
                this->_read_data(i,c,data);
                return data;
            }

            //----------------------------------------------------------------- 
            template<typename CTYPE> 
            void image(CTYPE &data,size_t i,size_t c=0) 
            {
                using namespace pni::core;
                image_info info = this->info(i);
                if(data.size() != info.npixels())
                {
                    std::stringstream ss;
                    ss<<"Container size ("<<data.size()<<") does not match";
                    ss<<"number of pixels ("<<info.npixels()<<")!";
                    throw size_mismatch_error(EXCEPTION_RECORD,ss.str());
                }

                //read data
                _read_data(i,c,data);
            }
          
            //-----------------------------------------------------------------
            friend std::ostream &operator<<(std::ostream &o,
                                            const tiff_reader &r);

    };

    template<typename CTYPE> 
        void tiff_reader::_read_data(size_t i,size_t c,CTYPE &data)
    {
        //obtain the proper IFD
        tiff::ifd &ifd = this->_ifds.at(i);
        std::ifstream &stream = this->_get_stream();

        //assume here that the image is stored using strips
        tiff::strip_reader reader(tiff::strip_reader::create(stream,ifd,this->info(i)));
        //std::cout<<reader<<std::endl;

        reader.read(c,stream,data);
        
    }
//end of namespace
}
}