CannyEdge.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 "Rescale.hh"
#include "CannyEdge.hh"

namespace BIAS {

  template<class InputStorageType, class OutputStorageType>
  CannyEdge<InputStorageType, OutputStorageType>::CannyEdge() {
    gsigma_ = 1.4f;
    edgeWidth_ = 1;
    useAbsThresholds_ = false;
    thresLow_ = 60;
    thresHigh_ = 10;
    Vector<FM_FLOAT> h(5), v(1);
    h[0] = 0.5f;
    h[1] = 1.0f;
    h[2] = 0.0f;
    h[3] = -1.0f;
    h[4] = -0.5f;
    v[0] = 1.0f;

    FilterMask f(h, v);
    ConvX_.SetKernel(f);
    
    FilterMask g(v, h);
    ConvY_.SetKernel(g);
    
  }

  template<class InputStorageType, class OutputStorageType>
  CannyEdge<InputStorageType, OutputStorageType>::~CannyEdge() {
  }

  template<class InputStorageType, class OutputStorageType>
  int CannyEdge<InputStorageType, OutputStorageType>::Filter(
      const Image<InputStorageType>& src, Image<OutputStorageType> &gx,
      Image<OutputStorageType>& gy, Image<OutputStorageType>& magnitude, 
      Image<OutputStorageType>& gdir, Image<OutputStorageType>& dst) {

    w_ = src.GetWidth();
    h_ = src.GetHeight();
    BIASASSERT(src.GetChannelCount() == 1);
    if (!gx.IsEmpty())
      gx.Release();
    if (!gy.IsEmpty())
      gy.Release();
    if (!gdir.IsEmpty())
      gdir.Release();
    if (!magnitude.IsEmpty())
      magnitude.Release();
    if (!dst.IsEmpty())
      dst.Release();
    gx.Init(w_,h_,1);
    gy.Init(w_,h_,1);
    magnitude.Init(w_,h_,1);
    gdir.Init(w_,h_,1);
    dst.Init(w_,h_,1);

    Image<OutputStorageType> smoothed;
    SmoothImage_(src, smoothed);

    CalculateGradients_(smoothed, gx, gy, magnitude, gdir, dst);

    return 0;
  }

  template<class InputStorageType, class OutputStorageType>
  int CannyEdge<InputStorageType, OutputStorageType>::SmoothImage_(
      const Image<InputStorageType>& src, Image<OutputStorageType>& smoothed) {

    Image<InputStorageType> tmp;
    Rescale<InputStorageType, InputStorageType> scaler;
    scaler.SetFactor(0.5f);
    scaler.Filter(src, tmp);
    gauss_.SetSigma(gsigma_);
    gauss_.Filter(tmp, smoothed);
    return 0;
  }

  template<class InputStorageType, class OutputStorageType>
  int CannyEdge<InputStorageType, OutputStorageType>::Filter(const Image<InputStorageType> & src, Image<OutputStorageType> & dst) {
    Image<OutputStorageType> intermediaries[4];
    int res = Filter(src, 
        intermediaries[0],
        intermediaries[1], 
        intermediaries[2],
        intermediaries[3], dst);
    return res;
  }

  template<class InputStorageType, class OutputStorageType>
    int CannyEdge<InputStorageType, OutputStorageType>::CalculateGradients_(
        const Image<OutputStorageType>& src, Image<OutputStorageType> & gx,
        Image<OutputStorageType>& gy, Image<OutputStorageType>& magnitude, 
        Image<OutputStorageType>& gdir, Image<OutputStorageType>& dst) {

    Image<OutputStorageType> tmpx, tmpy;
    tmpx.Init(w_*2, h_*2, 1);
    tmpy.Init(w_*2, h_*2, 1);
    ConvX_.Filter(src, tmpx);
    ConvY_.Filter(src, tmpy);
    
    // calculate magnitude and directions.
    OutputStorageType **idaTX = tmpx.GetImageDataArray();
    OutputStorageType **idaTY = tmpy.GetImageDataArray();
    OutputStorageType **idaX = gx.GetImageDataArray();
    OutputStorageType **idaY = gy.GetImageDataArray();
    OutputStorageType **idaM = magnitude.GetImageDataArray();
    OutputStorageType **idaD = gdir.GetImageDataArray();
    OutputStorageType **idaR = dst.GetImageDataArray();
    
    for (unsigned int y=0;y<h_*2;y+=2) {
      for (unsigned int x=0;x<w_*2;x+=2) {
        idaY[y/2][x/2] = idaTY[y][x];
        idaX[y/2][x/2] = idaTX[y][x];
      }
    }

    for (unsigned int y=0;y<h_;y++) {
      for (unsigned int x=0;x<w_;x++) {
        idaM[y][x] = (OutputStorageType)(abs((double)(idaY[y][x]))+abs((double)(idaX[y][x])));
      }
    }
    
    for (unsigned int y=0;y<h_;y++) {
      for (unsigned int x=0;x<w_;x++) {
        if (idaX[y][x] == 0) {
          if (idaY[y][x] == 0) {
            idaD[y][x] = 0;
          } else {
            if (idaY[y][x] < 0) {
              idaY[y][x] = -idaY[y][x];
            }
            idaD[y][x] = 90;
          }
        } else if(idaX[y][x]<0 && idaY[y][x]>0) {
          idaD[y][x] = (OutputStorageType)(180 - ((atan((double)(idaY[y][x])/(double)( -idaX[y][x]))) * (180/M_PI)));
        } else if(idaX[y][x]>0 && idaY[y][x]<0)   {
          idaD[y][x] = (OutputStorageType)(180 - ((atan((double)( -idaY[y][x])/(double)(idaX[y][x]))) * (180/M_PI)));
        } else {
          idaD[y][x] = (OutputStorageType)((atan((double)(idaY[y][x])/(double)(idaX[y][x]))) * (180/M_PI));
        }
        if(idaD[y][x] < 22.5) 
          idaD[y][x] = 0;
        else if(idaD[y][x] < 67.5) 
          idaD[y][x] = 45;
        else if(idaD[y][x] < 112.5) 
          idaD[y][x] = 90;
        else if(idaD[y][x] < 157.5) 
          idaD[y][x] = 135;
        else 
          idaD[y][x] = 0;
      }
    }

    OutputStorageType highThreshold = thresHighAbs_;
    OutputStorageType lowThreshold = thresLowAbs_;
    if (!useAbsThresholds_) {
      DetermineThresholds_(magnitude, lowThreshold, highThreshold);
      BIASCDOUT(D_FILTERBASE_CALLSTACK, "CannyEdge determined thresholds: " << lowThreshold << " " << highThreshold);
      if (lowThreshold == highThreshold) {
        lowThreshold = 60;
        highThreshold = 10;
        BIASWARN("CannyEdge could not determine thresholds automatically, resetting to: " << lowThreshold << " " << highThreshold);
      }
    }

    for (unsigned int y=edgeWidth_;y<h_-edgeWidth_;y++) {
      for (unsigned int x=edgeWidth_;x<w_-edgeWidth_;x++) {
        OutputStorageType leftNeighbor;
        OutputStorageType rightNeighbor;
        if(idaD[y][x] == 0)   {
          leftNeighbor = idaM[y][x-edgeWidth_];
          rightNeighbor = idaM[y][x+edgeWidth_];
        } else if(idaD[y][x] == 45)   {
          leftNeighbor = idaM[y+edgeWidth_][x-edgeWidth_];
          rightNeighbor = idaM[y-edgeWidth_][x+edgeWidth_];
        } else if(idaD[y][x] == 90)   {
          leftNeighbor = idaM[y-edgeWidth_][x];
          rightNeighbor = idaM[y+edgeWidth_][x];
        } else {
          leftNeighbor = idaM[y-edgeWidth_][x-edgeWidth_];
          rightNeighbor = idaM[y+edgeWidth_][x+edgeWidth_];
        }
        if (idaM[y][x] < leftNeighbor || idaM[y][x] < rightNeighbor) {
          idaR[y][x] = 0;
        } else {
          if(idaM[y][x] >= highThreshold) {
            idaR[y][x] = 255;
          } else if(idaM[y][x] < lowThreshold) {
            idaR[y][x] = 0;
          } else {
            idaR[y][x] = 0;
            for (unsigned int yw=y-1;yw<=y+1;yw++) {
              for (unsigned int xw=x-1;xw<=x+1;xw++) {
                if (idaR[yw][xw]>=highThreshold) {
                  idaR[y][x] = 255;
                  break;
                }
              }
            }
          }
        }
      }
    }
    
    return 0;
  }

  template <class InputStorageType, class OutputStorageType>
  void CannyEdge<InputStorageType, OutputStorageType>::GetBordersValid_(int& border_x, int& border_y) const {
    BIASERR("no parameter support");
    BIASABORT;
  }

  template<class InputStorageType, class OutputStorageType> 
  int CannyEdge<InputStorageType, OutputStorageType>::DetermineThresholds_(const Image<OutputStorageType> &src, OutputStorageType &low, OutputStorageType &high)
  {
    const OutputStorageType *ida = src.GetImageData();
    OutputStorageType min, max;
    src.GetMinMaxPixelValue(min, max);
    if (max==0 || max==min) {
      BIASERR("can not determine thresholds");
      BIASABORT;
    }
    unsigned int histo[256];
    unsigned int idx = 0;
    for (;idx<256;idx++) {
      histo[idx]=0;
    }
    unsigned int allPixelCount = src.GetPixelCount();
    unsigned int upperPercent = allPixelCount * thresHigh_ / 100;
    unsigned int lowerPercent = allPixelCount * thresLow_ / 100;
    for (unsigned int i=0;i<allPixelCount;i++) {
      idx = (unsigned int)((float)(ida[i] - min) / (float)(max-min) * 255.0f);
      histo[idx] ++;
    }
    idx = 255;
    while (histo[idx] <= upperPercent) {
      upperPercent -= histo[idx];
      idx--;
    }
    high = (OutputStorageType)((float)idx / 255.0f * (max-min) + min);
    idx = 0;
    while (histo[idx] <= lowerPercent) {
      lowerPercent -= histo[idx];
      idx++;
    }
    low = (OutputStorageType)((float)idx / 255.0f * (max-min) + min);
    return 0;
  }
  
  template<class InputStorageType, class OutputStorageType> 
  int CannyEdge<InputStorageType, OutputStorageType>::SetGaussSigma(float sigma)
  {
    gsigma_=sigma;
    return 0;
  }

  template<class InputStorageType, class OutputStorageType> 
  int CannyEdge<InputStorageType, OutputStorageType>::SetThresholdsAbsolute(OutputStorageType lowAbs_, OutputStorageType highAbs_)
  {
    useAbsThresholds_ = true;
    thresLowAbs_ = lowAbs_;
    thresHighAbs_ = highAbs_;
    return 0;
  }

  template<class InputStorageType, class OutputStorageType> 
  int CannyEdge<InputStorageType, OutputStorageType>::SetThresholdsRelative(unsigned int low_, unsigned int high_)
  {
    useAbsThresholds_ = false;
    thresLow_ = low_;
    thresHigh_ = high_;
    return 0;
  }
  
  template<class InputStorageType, class OutputStorageType> 
  int CannyEdge<InputStorageType, OutputStorageType>::SetEdgeWidth(unsigned int edgeWidth)
  {
    edgeWidth_ = edgeWidth;
    return 0;
  }
  
  
//////////////////////////////////////////////////////////////////////////
//                 instantiation
//////////////////////////////////////////////////////////////////////////

#define FILTER_INSTANTIATION_CLASS CannyEdge
#define FILTER_INSTANTIATION_NO_UNSIGNED_OUTPUT

// small range data types not supported at this time
#ifdef BUILD_IMAGE_CHAR
#define CANNYUNDEF_CHAR
#undef BUILD_IMAGE_CHAR
#endif
  
#ifdef BUILD_IMAGE_USHORT
#undef BUILD_IMAGE_USHORT
#define CANNYUNDEF_USHORT
#endif
  
#include "Filterinst.hh"
  
#ifdef CANNYUNDEF_CHAR
#define BUILD_IMAGE_CHAR
#undef CANNYUNDEF_CHAR
#endif
  
#ifdef CANNYUNDEF_USHORT
#define BUILD_IMAGE_USHORT
#undef CANNYUNDEF_USHORT
#endif
  
#undef FILTER_INSTANTIATION_NO_UNSIGNED_OUTPUT
#undef FILTER_INSTANTIATION_CLASS

} // namespace BIAS