ConstantRegionDetector.cpp

/*
 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
 */

#include "ConstantRegionDetector.hh"
#include <Base/Image/ImageIO.hh>
#include <Filter/Median.hh>
#include <algorithm>

using namespace std;
using namespace BIAS;


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


template<class StorageType, class CalculationType>
ConstantRegionDetector<StorageType, CalculationType>::ConstantRegionDetector(){
  threshold_ = (CalculationType)1;
  halfWinSize_ = 2;
  maxNumFeatures_ = -1;
  maskImg_ = Image<unsigned char>(0, 0, 1);
  minDistance_ = -1;
}

template<class StorageType, class CalculationType>
ConstantRegionDetector<StorageType, CalculationType>::~ConstantRegionDetector(){
}

template<class StorageType, class CalculationType> int ConstantRegionDetector<
    StorageType, CalculationType>::Detect(Image<StorageType>& src, std::vector<
    HomgPoint2D>& points2d, vector<Vector3<StorageType> >& colors,
                                          bool useMedian){

  if (useMedian) {
    Image<StorageType> imMed;
    Median<StorageType, StorageType> median;
    median.SetSize(3, 3);
    median.FilterColorImg(src, imMed);
    src = imMed;
  }

  points2d.clear();
  colors.clear();
  featureList_.clear();

  bool checkMask = false;
  cout << "mask? " << maskImg_.GetWidth() << " " << maskImg_.GetHeight() << endl;
  if(maskImg_.GetWidth() == src.GetWidth() && maskImg_.GetHeight() == src.GetHeight()){
    checkMask = true;
  }

  StorageType** imageData = src.GetImageDataArray();
  unsigned char** maskData = maskImg_.GetImageDataArray();
  int imgWidth = (int)src.GetWidth();
  int imgHeight = (int)src.GetHeight();
  
  for (int i = halfWinSize_; i < (imgWidth - halfWinSize_); i++) {
    for (int j = halfWinSize_; j < (imgHeight - halfWinSize_); j++) {

      // check if mask image is set and if pixel is to be omitted
      if(checkMask && (maskData[j][i] > (unsigned char)0)){
        continue;
      }
      
      CalculationType sqrDiffR = 0;
      CalculationType sqrDiffG = 0;
      CalculationType sqrDiffB = 0;
      for (int ii = -halfWinSize_; ii <= halfWinSize_; ii++) {
        for (int jj = -halfWinSize_; jj <= halfWinSize_; jj++) {
          sqrDiffR = sqrDiffR + (CalculationType) pow((float) imageData[j][i*3+0]
              - (float) imageData[j+jj][(i+ii)*3+0], 2.0f);
          sqrDiffG = sqrDiffG + (CalculationType) pow((float) imageData[j][i*3+1]
              - (float) imageData[j+jj][(i+ii)*3+1], 2.0f);
          sqrDiffB = sqrDiffB + (CalculationType) pow((float) imageData[j][i*3+2]
              - (float) imageData[j+jj][(i+ii)*3+2], 2.0f);
        }
      }
      float numMeasurements = (halfWinSize_ * 2.0f + 1.0f) * (halfWinSize_ * 2.0f + 1.0f) * 3.0f; 
      sqrDiffR = CalculationType((float)sqrDiffR / numMeasurements);
      sqrDiffG = CalculationType((float)sqrDiffG / numMeasurements);
      sqrDiffB = CalculationType((float)sqrDiffB / numMeasurements);

      CalculationType qual = sqrDiffR + sqrDiffG + sqrDiffB;

      if (qual < threshold_) {
        ColFeat<StorageType> feature;
        feature.x = i;
        feature.y = j;
        feature.val = qual;
        feature.col = Vector3<StorageType> (imageData[j][i*3+0], imageData[j][i*3+1], imageData[j][i*3+2]);
        featureList_.push_back(feature);
        points2d.push_back(HomgPoint2D(i, j, 1.0));
        colors.push_back(Vector3<StorageType> (imageData[j][i*3+0], imageData[j][i*3+1], imageData[j][i*3+2]));

      }

    } // end for j
  } // end for i

  // enforce min distance
  if(minDistance_ != -1){
    sort(featureList_.begin(), featureList_.end());
    
    Image<unsigned char> regionMap(imgWidth, imgHeight, 1);
    regionMap.SetZero();
    unsigned char** regionMapData = regionMap.GetImageDataArray();
    
    unsigned int numRegions = featureList_.size();
    
    int xcoor, ycoor, winCoorX, winCoorY;
    
    points2d.clear();
    colors.clear();
    vector<ColFeat<StorageType> > tempList;
    
    for(unsigned int i=0; i < numRegions; i++){
      xcoor = featureList_[i].x;
      ycoor = featureList_[i].y;
      if(regionMapData[ycoor][xcoor]==(unsigned char)0){ // no region yet -- draw and add to final list
        for(int xx = -minDistance_; xx <= minDistance_; xx++){
          for(int yy=-minDistance_; yy <= minDistance_; yy++){
            winCoorX = xcoor + xx;
            winCoorY = ycoor + yy;
            if(winCoorX >= 0 && winCoorX < imgWidth && winCoorY >= 0 && winCoorY < imgHeight){
              regionMapData[winCoorY][winCoorX] = (unsigned char)1;
            }
          }
        } // end for xx (drawing forbidden region in regionMap image
        // adding region to be kept to output data structures
        tempList.push_back(featureList_[i]);
        points2d.push_back(HomgPoint2D(xcoor, ycoor, 1.0));
        colors.push_back(Vector3<StorageType>(imageData[ycoor][xcoor*3+0], imageData[ycoor][xcoor*3+1], imageData[ycoor][xcoor*3+2]));
      } 
      
    }
    
    featureList_ = tempList;
    
  } // end if min Distance != -1
  
  
  if(maxNumFeatures_ != -1){
    sort(featureList_.begin(), featureList_.end());

    points2d.clear();
    colors.clear();
    ColFeat<StorageType> featureTmp;
    for(int i = 0; i < maxNumFeatures_; i++){
      featureTmp = featureList_.back();
      featureList_.pop_back();
      points2d.push_back(HomgPoint2D(featureTmp.x, featureTmp.y, 1.0));
      colors.push_back(featureTmp.col);
    }

  }


  return 0;
}



//////////////////////////////////////////////////////////////////////////
//                 instantiation
//////////////////////////////////////////////////////////////////////////

//template class ColFeat<unsigned char>;
//template class ColFeat<float>;
namespace BIAS{
template class ConstantRegionDetector<unsigned char, float> ;
template class ConstantRegionDetector<float, float> ;

// fill in instances as required
#ifdef BUILD_IMAGE_INT
template class ConstantRegionDetector<unsigned char, int>;
#endif
#ifdef BUILD_IMAGE_CHAR
template class ConstantRegionDetector<unsigned char, char>;
#endif
#ifdef BUILD_IMAGE_SHORT
#endif
#ifdef BUILD_IMAGE_USHORT
template class ConstantRegionDetector<unsigned short, float>;
#ifdef BUILD_IMAGE_INT
template class ConstantRegionDetector<unsigned short, int>;
#endif
#endif
#ifdef BUILD_IMAGE_UINT
#endif
#ifdef BUILD_IMAGE_DOUBLE
#endif
}