CalibratedPyramid.hh

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS 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 2.1 of the License, or
   (at your option) any later version.
   
   BIAS 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 BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/

#ifndef __CalibratedPyramid_hh__
#define __CalibratedPyramid_hh__

#include <Base/Common/SharedPtr.hh>
#include <Image/PyramidImage.hh>

namespace BIAS {

  // forwrad declarations
  template <class T> class BIASImageBase_EXPORT Image; 
  class BIASGeometry_EXPORT ProjectionParametersBase;

  /** @class CalibratedImage
      @relates CalibratedPyramid
      @brief helper class holding image and associated calibration
      @author woelk 12/2007 (c) www.vision-n.de */ 
  template <class StorageType>
  class BIASImage_EXPORT CalibratedImage 
  {
  public:
    SharedPtr<Image<StorageType> > image;
    SharedPtr<ProjectionParametersBase> projection;
  };


  /** @class CalibratedPyramid
      @brief This class takes care of consisiten re-sampling of images and 
      associated ProjectionParameters.
      @author woelk 12/2007 (c) www.vision-n.de */ 
  template <class StorageType>
  class BIASImage_EXPORT CalibratedPyramid
  {
  public:
    CalibratedPyramid();

    CalibratedPyramid(const PyramidImage<StorageType>& cp);

    CalibratedPyramid(const CalibratedPyramid<StorageType>& cp);

    ~CalibratedPyramid();

    /// initialization with original image, total number of images in the
    /// pyramid and a rescale factor. A rescale factor of 4.0 means the 
    /// the image at pyramid level[i] has a quarter of the border lengths of 
    /// the image at pyramid level[i-1]. A rescale factor of 2.0 for example
    /// represent a classical Gaussian pyramid.
    void Init(const CalibratedImage<StorageType>& image,
              const unsigned pyramid_size = 2, 
              const double rescale_factor = 4.0);

    /// clears the pyramid image and the internal vector,
    /// does not explicitly delet the pointers
    void Clear();

    /// check for emptyness
    inline bool IsEmpty() const
    { return Data_.empty(); }

    /// access operator
    const CalibratedImage<StorageType>& operator[](const unsigned index) const
    { return Data_[index]; }

    /// access operator
    CalibratedImage<StorageType>& operator[](const unsigned index)
    { return Data_[index]; }

    /// shallow copy operator, only copies the pointers
    CalibratedPyramid<StorageType>& 
    operator=(const CalibratedPyramid<StorageType>& cp);

    // coordinate transformation from level 0 -> index
    void CoordinateTransf(const Vector2<double>& coo0, const unsigned index,
                          Vector2<double>& coo_index) const;

    /////////////////////////////////////////////////////
    // get operators
    /////////////////////////////////////////////////////

    /// returns the number of images stored in the pyramid
    inline unsigned Size() const
    { return PyramidImage_.GetPyramidSize(); };

    /// get the subsampling factor: 2.0 equals 
    inline double GetRescaleFactor() const 
    { return PyramidImage_.GetRescaleFactor(); }
    
    inline double GetPositionOffset() const
    { return PyramidImage_.GetPositionOffset(); }

  protected:
    /// Internal data: Data_.size() must always be equal to 
    /// PyramidImage_.GetPyramidSize()

    /// holds the images
    PyramidImage<StorageType> PyramidImage_;
    /// holds the projection parameters and ptrs to the associated images 
    std::vector<CalibratedImage<StorageType> > Data_;
    
    /** Downsampling for factor 2 or 4, using a binomial lowpass filter. */
    void Downsample_(SharedPtr<const Image<StorageType> > src, 
                     SharedPtr<Image<StorageType> > dst, 
                     const unsigned factor) const;

    double PositionOffset_;
  };




} // namespace

#endif // __CalibratedPyramid_hh__