ImageReader.hpp

/* $Id$ */

#ifndef IMAGE_IMAGE_READER_HPP
#define IMAGE_IMAGE_READER_HPP

#include <string>

#include "kernel/jafarMacro.hpp"
#include "kernel/keyValueFile.hpp"
#include "image/cImage.h"

namespace jafar {
  namespace image {
    class Image;
    class ImagePreprocessor;
  }
  namespace datareader {

    enum BayerType { 
      bayerNo = 0, 
      bayerBG = JfrImage_CS_BayerBG, 
      bayerGB = JfrImage_CS_BayerGB, 
      bayerRG = JfrImage_CS_BayerRG, 
      bayerGR = JfrImage_CS_BayerGR 
    };
    
    class ImageReader {

    private:
      std::string directory;
      std::string pattern;
      int width;
      int height;
      int depth;
      double reduction;
      int first;
      int last;
      int step;
      BayerType isBayerized;
      bool isRectified;
      double scale;

      jafar::image::ImagePreprocessor* m_imagePreprocessor;
    public:

      ImageReader() : scale(1.0), m_imagePreprocessor(0) {}

/*      // for back compatibility purpose ; not compatible with swig for default parameters, ambiguity
      void setup(std::string directory_,
        std::string prefix_ = "image.",
        std::string suffix_ = ".tiff",
        unsigned int indexDigits_ = 4,
        double scale_ = 1.0,
        bool isBayerized_ = false,
        int width_ = -1, int height_ = -1, int depth_ = -1,
        int first_ = -1, int last_ = -1, int step_ = 1,
        double reduction = 1.0,
        bool isRectified_ = false)
      {
        setup(directory_, prefix_+std::string("%0")+std::string(1,'0'+indexDigits_)+std::string("d")+suffix_,
          scale_, isBayerized_, width_, height_, depth_, first_, last_, step_, reduction, isRectified_);
      }*/

      void setup(std::string directory_,
        std::string pattern_ = "image.%04d.tiff",
        double scale_ = 1.0,
        BayerType isBayerized_ = bayerNo,
        int width_ = -1, int height_ = -1, int depth_ = -1,
        int first_ = -1, int last_ = -1, int step_ = 1,
        double reduction = 1.0,
        bool isRectified_ = false);

      std::string getFilePath(unsigned int index) const;

      int getImageWidth() const { return width; }
      int getImageHeight() const { return height; }
      int getImageDepth() const { return depth; }
      double getOriginalReduction() const { return reduction; }
      int getFirstIndex() const { return first; }
      int getLastIndex() const { return last; }
      int getIndexStep() const { return step; }
      double getScale() const { return scale; }
      bool isImageBayerized() const { return isBayerized; }
      bool isImageRectified() const { return isRectified; }

      void loadImage(unsigned int index_, image::Image& image) const;

      jafar::image::Image* loadImage(unsigned int index_) const;

      inline void setImagePreprocessor(jafar::image::ImagePreprocessor* imagePreprocessor)
      {
        m_imagePreprocessor = imagePreprocessor;
      }
    }; // class ImageReader

#ifndef SWIG
    class JAFAR_DEPRECATED StereoImageReader {
#else
    class StereoImageReader {
#endif

    private:
      ImageReader m_leftImageReader;
      ImageReader m_rightImageReader;

    public:
      StereoImageReader() {}


/*      // for back compatibility purpose ; not compatible with swig for default parameters, ambiguity
      void setup(std::string directory_,
        std::string prefix_ = "image.",
        std::string leftSuffix_ = ".l",
        std::string rightSuffix_ = ".r",
        std::string suffix_ = ".tiff",
        unsigned int indexDigits_ = 4,
        double scale_ = 1.0,
        bool isBayerized_ = false,
        int width_ = -1, int height_ = -1, int depth_ = -1,
        int first_ = -1, int last_ = -1, int step_ = 1,
        double reduction = 1.0,
        bool isRectified_ = false)
      {
        setup(directory_, prefix_+leftSuffix_+std::string("%0")+std::string(1,'0'+indexDigits_)+std::string("d")+suffix_,
          prefix_+rightSuffix_+std::string("%0")+std::string(1,'0'+indexDigits_)+std::string("d")+suffix_,
          scale_ , isBayerized_, width_, height_, depth_, first_, last_, step_, reduction, isRectified_);
      }*/


      void setup(std::string directory_,
        std::string leftPattern_ = "image.l.%04d.tiff",
        std::string rightPattern_ = "image.r.%04d.tiff",
        double scale_ = 1.0,
        BayerType isBayerized_ = bayerNo,
        int width_ = -1, int height_ = -1, int depth_ = -1,
        int first_ = -1, int last_ = -1, int step_ = 1,
        double reduction = 1.0,
        bool isRectified_ = false);

      jafar::image::Image* loadLeft(unsigned int index_) const;
      jafar::image::Image* loadRight(unsigned int index_) const;

    }; // class StereoImageReader
  }
}
#endif // IMAGE_IMAGE_READER_HPP