ImageBlender.hh

#ifndef __ImageBlender_hh__
#define __ImageBlender_hh__

#include <Base/Image/Image.hh>
#include <Image/Camera.hh>
#include <Base/Image/ImageConvert.hh>
#include <Filter/Gauss.hh>
#include <Geometry/ProjectionParametersCylindric.hh>
#include <Geometry/ProjectionParametersPerspective.hh>
#include <Image/ProjectionMapping.hh>
#include <Geometry/Projection.hh>

#define WEIGHT_TYPE_NONE           0
#define WEIGHT_TYPE_CIRCULAR       1
#define WEIGHT_TYPE_CIRCULAR_FIT   2
#define WEIGHT_TYPE_RECTANGULAR    3
#define WEIGHT_TYPE_RECT_NONLINEAR 4
#define WEIGHT_TYPE_MIX            5 // mix between rectangular and circular


// these defines steer the orientaion of the cylinder with X/Y/Z-axes of the
// cameras or automatically
#define HORIZON_ALIGNMENT_X 0
#define HORIZON_ALIGNMENT_Y 1
#define HORIZON_ALIGNMENT_UNKNOWN 2
#define HORIZON_ALIGNMENT_AUTO 3

// DEBUG LEVELS:
// gives some output about the whole progress
#define D_IMAGEBLENDER_MINIMAL   1
// gives some output about geometry calculation
#define D_IMAGEBLENDER_GEOMETRY  2
// gives some output about the filtering process
#define D_IMAGEBLENDER_FILTERING 4
// gives some output about the blending
#define D_IMAGEBLENDER_BLENDING  8


namespace BIAS {
  
  /** @class ImageBlender
   *  @brief maps images into a common camera and blends them seamlessly
   *
   *  Blends a bunch of images seamlessly.  
   *  You can add as many images as you like to the database using AddCamera().
   *  The projection of each camera is needed, so ensure that the camera you're
   *  adding contains a valid projection.
   *  To blend the images you've added to the database call BlendImages().
   *  Originally this class was written for panoramic image stitiching and
   *  computes a cylindrical geometry automatically from the different
   *  images. However, you can specify any projection you want as an output.
   *  In case your input images do not have the same camera center as your
   *  output image and you want this to be considered, you have to provide
   *  an output depth map, which can be used for the mapping in 3D.
   *
   *  Blending is done by separating the image into high-pass and low-pass
   *  parts, where each part is blended over one wavelength, i.e. sharp edges
   *  are blended within 2 pixels, while the image mean is blended over
   *  the whole image size.
   *  @author Robert Wulff
   *  @date 07/2007
   **/
  class BIASImage_EXPORT ImageBlender : public BIAS::Debug {
    
    public:
    
    /** @brief constructor
        @author Robert Wulff
        @date 07/2007
    **/
    ImageBlender();
    
    /** @brief Adds an image to the database. The image must contain a valid
        projection and a valid UUID.
        @return 0 = OK, -1 = error
        @author Robert Wulff
        @date 07/2007
    **/
    int AddCamera(const BIAS::Camera<unsigned char>& camera,
                  unsigned int weightType = WEIGHT_TYPE_RECTANGULAR);
    
    /** @brief compute cylindrical geometry from added images and blend all
        added images

        wrapper function only, calls other BlendImages
        @param destination result image
        @return true iff blending succeeded or false otherwise
        @author Robert Wulff
        @date 07/2007
    **/
    inline bool BlendImages(BIAS::Camera<unsigned char> &destination,
                            double gaussSigma = 1.2) {
      // compute cyl geometry
      ProjectionParametersCylindric ppc(-cylinderHeight_, cylinderHeight_, 
                                        -M_PI, M_PI,
                                        cylindricImageWidth_,
                                        cylindricImageHeight_);
      ComputeCylCamGeometry(ppc);
      return BlendImages(destination, ppc, NULL, gaussSigma);
    }
    

    /** @brief Blends all added images into destination with ppOut projection
     *  @param destination output image
     *  @param ppOut desired projection for output
     *  @param depthmap of destination, needed if input cameras do not have the
     *         same center as output camera, ignored if NULL
     *  @return true iff blending succeeded or false otherwise
     *  @author Robert Wulff
     *  @date 07/2007
    **/
    bool BlendImages(BIAS::Camera<unsigned char> &destination,
                     const ProjectionParametersBase& ppOut,
                     const BIAS::Image<float>* depthmap = NULL,
                     double gaussSigma = 1.2);


    /** @brief 
        @author Robert Wulff
        @date 10/2007
    **/
    inline void SetOuputImageSize(const unsigned int &newSize) {
      cylindricImageHeight_ = newSize;
      cylindricImageWidth_  =
        (unsigned int)(cylindricImageHeight_ * cylinderHeight_ / M_PI);
    };
    
    /** @brief 
        @author Robert Wulff
        @date 10/2007
    **/
    inline unsigned int GetOuputImageSize() {
      return cylindricImageWidth_;
    };
    
    // creates a 3d model of image planes and cyl cam
    inline void SetWriteVrml(bool flag) {writeVrml_ = flag;}
    
    inline void SetDrawImageBorders(bool flag) {drawImageBorders_ = flag;}
    
    // here come the public member variables
    
    /** @brief determines the alignment of the horizon
               possible values are:
               HORIZON_ALIGNMENT_X - horizon is in x direction (default value)
               HORIZON_ALIGNMENT_X - horizon is in y direction
               HORIZON_ALIGNMENT_UNKNOWN - horizon alignment is unknown
                                           or mixed
        @date 12/07
    **/
    inline void SetHorizonAlignment(unsigned int val) {horizonAlignment_ = val;};
    
  protected:
    
    /** @brief adds an alpha channel to RGB image, alpha can be e.g. radial
        symmetric from image center*/
    inline void 
    ComputeAlphaChannelWeight(BIAS::Image<float> &image,
                              unsigned int weightType = 
                              WEIGHT_TYPE_RECTANGULAR);
    
    inline void ConvertImageToRGBA(BIAS::Image<float> &image);
    
    void ComputeCylCamGeometry(BIAS::ProjectionParametersCylindric &ppc);
    
    inline double CalcAngleToYAxis(const BIAS::Vector2<double> &v,
                                   bool wantDegrees = false);
    
    inline double CalcAngleToXAxis(const BIAS::Vector2<double> &v,
                                   bool wantDegrees = false);
    
    /** @brief Checks FOV of each cam and computes the cylinder's FOV
               If mapper tries to access pixel outside of image, nasty
               distortion effects occur. This method checks the FOV of each cam
               and blocks access to pixels that are out of scope.
        @author Robert Wulff
        @date 11/07
    **/
    inline void CheckFov(BIAS::ProjectionParametersCylindric &ppc);
    
    // here come the protected member variables
    double cylinderHeight_;
    unsigned int cylindricImageWidth_;
    unsigned int cylindricImageHeight_;
    unsigned int horizonAlignment_;
    
    std::vector<BIAS::UUID> imageIDs_;
    std::map<BIAS::UUID, BIAS::Camera<float> > inputImages_;
    
    BIAS::Gauss<float, float> gaussFilter_;
    
    bool writeVrml_;
    bool drawImageBorders_;
  };
}
#endif // __ImageBlender_hh__