TestFilterBase.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 __TestFilterBase_hh__
#define __TestFilterBase_hh__

#include <Base/Debug/Error.hh>
#include <Base/Image/Image.hh>
#include <Filter/FilterBase.hh>
#include <Filter/FilterMask.hh>

#include <iostream>
/**
 *  @file TestFilterBase.hh
 */
using namespace std;

namespace BIAS {

  /** @class FilterTestPair   
      @brief struct holding ground truth data for filter testing\    
      @relates TestFilterBase
      @author woelk 06/2008 (c) www.vision-n.de */
  template <typename InputStorageType, typename OutputStorageType>
  class FilterTestPair
  {
  public:
    FilterTestPair(const Image<InputStorageType> input, 
                   const Image<OutputStorageType> output)
      : Input(input), Output(output), 
        BorderHandling(FilterBase<InputStorageType, 
                       OutputStorageType>::TBH_valid), Mask() {}

    Image<InputStorageType> Input; ///< input image
    Image<OutputStorageType> Output; /// ground truth output
    enum FilterBase<InputStorageType, OutputStorageType>::TBorderHandling BorderHandling;
    FilterMask Mask;
  };



  /** @class TestFilterBase
      @brief helper class for testing individual filters
      
      Instatiate this class with the approriat filter, add some grond truth
      test data using the function AddTestData() and finally call
      Test() to do some basic testing of the filter

      See TestFilterBinomial as an example
      
      @author woelk 06/2008 (c) www.vision-n.de */
  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  class TestFilterBase
  {
  public:
    TestFilterBase() {};
    
    ~TestFilterBase() {};
    
    bool Test();

    void AddTestData(const FilterTestPair<InputStorageType, 
                                          OutputStorageType> &data);

  protected:
    // the filter to be tested
    FILTER<InputStorageType, OutputStorageType> Filter_;
    // the test data used for testing
    std::vector<FilterTestPair<InputStorageType, OutputStorageType> > Data_;

    // checks all data sets from Data_
    bool TestData_();

    // checks if bordr handling is correctly implemented
    bool TestBorderHandling_();
    
    // compares the image header
    bool CompareHeader_(const Image<InputStorageType> &src, 
                        const Image<OutputStorageType> &dst) const;

    // compares the image data within ROI of dst
    bool CompareImageData_(const Image<OutputStorageType> &gt, 
                           const Image<OutputStorageType> &dst) const;

  }; // class
  



  
  ////////////////////////////////////////////////////////
  // implementation
  ////////////////////////////////////////////////////////

  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  bool TestFilterBase<FILTER, InputStorageType, OutputStorageType>::
  Test()
  {
    if (!TestBorderHandling_()) { return false; }

    if (!TestData_()) { return false; }

    return true;
  }



  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  void TestFilterBase<FILTER, InputStorageType, OutputStorageType>::
  AddTestData(const FilterTestPair<InputStorageType, OutputStorageType> &data)
  {
    // TODO: consistency check
    Data_.push_back(data);
  }



  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  bool TestFilterBase<FILTER, InputStorageType, OutputStorageType>::
  TestBorderHandling_()
  {
    const int sze = 100, roioffs = 2;
    BIASASSERT(2*roioffs<sze);
    // prepare sourec image
    Image<InputStorageType> src(sze, sze, 1);
    Image<OutputStorageType> dst;
    src.FillImageWithConstValue((InputStorageType)0);
    const unsigned src_roi[]={roioffs, roioffs, sze-roioffs, sze-roioffs};
    src.SetROICorners(src_roi[0], src_roi[1], src_roi[2], src_roi[3]);
    unsigned dst_roi[4];

    // check 'valid'
    Filter_.SetBorderHandling(FilterBase<unsigned char, unsigned char>::
                              TBH_valid);
    if (Filter_.Filter(src, dst)!=0){ BIASABORT; }
    if (!CompareHeader_(src, dst)) { BIASABORT; }
    dst.GetROICorners(dst_roi[0], dst_roi[1], dst_roi[2], dst_roi[3]);
    int roi_offs[4]; // the offsets
    Filter_.GetBorders(roi_offs[0], roi_offs[1]);
    roi_offs[2] = -roi_offs[0]; roi_offs[3] = -roi_offs[1];
    for (int i=0; i<4; i++){
      //cout << "src_roi: "<<src_roi[i]<<"\tdst_roi: "<<dst_roi[i]
      //     <<"\troi_offs: "<<roi_offs[i]<<endl;
      if ((int)src_roi[i] + roi_offs[i] != (int)dst_roi[i]){ BIASABORT; }
    }

    // check 'same'
    Filter_.SetBorderHandling(FilterBase<unsigned char, unsigned char>::
                              TBH_same);
    if (Filter_.Filter(src, dst)!=0){ BIASABORT; }
    if (!CompareHeader_(src, dst)) { BIASABORT; }
    dst.GetROICorners(dst_roi[0], dst_roi[1], dst_roi[2], dst_roi[3]);
    for (int i=0; i<4; i++){
      if (src_roi[i] != dst_roi[i]){ BIASABORT; }
    }

    return true;
    
    // boder handing full does not work so far
//     Filter_.SetBorderHandling(FilterBase<unsigned char, unsigned char>::
//                               TBH_full);
//     if (Filter_.Filter(src, dst)!=0){ BIASABORT; }
    //if (!CompareHeader_(src, dst)) { BIASABORT; }
    // return true;
  }
    

  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  bool TestFilterBase<FILTER, InputStorageType, OutputStorageType>::
  TestData_()
  {
    for (unsigned i=0; i<Data_.size(); i++){
      Image<OutputStorageType> dst;
      Filter_.SetBorderHandling(Data_[i].BorderHandling);
      if (Filter_.Filter(Data_[i].Input, dst)!=0){ BIASABORT; }
      if (!CompareHeader_(Data_[i].Output, dst)) { BIASABORT; }
      if (!CompareImageData_(Data_[i].Output, dst)) { BIASABORT; }
    }
    return true;
  }


  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  bool TestFilterBase<FILTER, InputStorageType, OutputStorageType>::
  CompareHeader_(const Image<InputStorageType> &src, 
                 const Image<OutputStorageType> &dst) const
  {
    if (src.GetWidth() != dst.GetWidth()){ BIASABORT; }
    if (src.GetHeight() != dst.GetHeight()){ BIASABORT; }
    if (src.GetChannelCount() != dst.GetChannelCount()){ BIASABORT; }
    if (src.GetColorModel() != dst.GetColorModel()){ BIASABORT; }
    if (src.IsInterleaved() != dst.IsInterleaved()){ BIASABORT; }
    return true;
  }

  template <template <typename, typename> class FILTER, 
            typename InputStorageType, typename OutputStorageType>
  bool TestFilterBase<FILTER, InputStorageType, OutputStorageType>::
  CompareImageData_(const Image<OutputStorageType> &gt, 
                    const Image<OutputStorageType> &dst) const
  {
    if (!gt.SamePixelAndChannelCount(dst)) { BIASABORT; }
    unsigned gt_roi[4], dst_roi[4];
    gt.GetROICorners(gt_roi[0], gt_roi[1], gt_roi[2], gt_roi[3]);
    dst.GetROICorners(dst_roi[0], dst_roi[1], dst_roi[2], dst_roi[3]);
   //  for (int i=0; i<4; i++){
//       if (gt_roi[i] < dst_roi[i]){ BIASABORT; }
//     }
    const OutputStorageType **dst_ida = dst.GetImageDataArray();
    const OutputStorageType **gt_ida = gt.GetImageDataArray();
    const unsigned cc = gt.GetChannelCount();
    register unsigned x, y, c;
    for (y=dst_roi[1]; y<dst_roi[3]; y++){
      for (x=dst_roi[1]; x<dst_roi[3]; x++){
        for (c=0; c<cc; c++){
          if (!Equal(dst_ida[y][x*cc+c], gt_ida[y][x*cc+c])) { 
            cout << "y: "<<y<<"\tx: "<<x<<"\tcc: "<<cc<<"\tcc: "<<c<<endl
                 << "dst_ida[y][x*cc+c]: "<<(int)dst_ida[y][x*cc+c]
                 <<"\tgt_ida[y][x*cc+c]: "<<(int)gt_ida[y][x*cc+c]<<endl;
            BIASABORT; 
          }
        }
      }
    }

    return true;
  }

} // namespace


#endif // __TestFilterBase_hh__