Erosion.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 "Erosion.hh"

using namespace BIAS;
using namespace std;

template <class InputStorageType, class OutputStorageType> 
int Erosion<InputStorageType, OutputStorageType>::
Erode(const Image<InputStorageType>& Source,
      Image<OutputStorageType>& Destination, 
      int KernelSize) {
  if (Destination.IsEmpty()) {
    Destination.Init(Source.GetWidth(), Source.GetHeight(), 
                     Source.GetChannelCount());
    Destination.SetColorModel(ImageBase::CM_Grey);
  }
#ifdef BIAS_BOUNDS_CHECK
  if (Source.GetChannelCount() !=1)
    BIASERR("Erosion<StorageType>::Dilate() only implemented for grey images");
  if (! Source.SamePixelAndChannelCount(Destination))
    BIASERR("Erosion<StorageType>::Dilate()  wrong images sizes");
  if (KernelSize % 2 != 1)
    BIASERR("Erosion<StorageType>::Dilate()  odd KernelSize required");
#endif

  int Width = Source.GetWidth();
  int Height = Source.GetHeight();
  register int HalfKernelSize = (KernelSize - 1) / 2;
  register OutputStorageType **DestArray = Destination.GetImageDataArray();  
  register const InputStorageType **SourceArray = Source.GetImageDataArray(); 

  // loop
  for (register int y = HalfKernelSize; 
       y < (Height - HalfKernelSize); y++) {
    for (register int x = HalfKernelSize; 
         x < (Width - HalfKernelSize); x++) {
      DestArray[y][x] = OutputStorageType(SourceArray[y][x]);
      for (register int ky = -HalfKernelSize; ky <= HalfKernelSize; ky++)
        for (register int kx = -HalfKernelSize; kx <= HalfKernelSize; kx++)
          if ( (DestArray[y][x]==0) || (SourceArray[y+ky][x+kx]==0) )
            DestArray[y][x] = 0;   
    }     
  }

  // fill borders with zero
  this->FillBorderConst(Destination, (unsigned short int)HalfKernelSize,
                  (unsigned short int)HalfKernelSize, (OutputStorageType)0);
  return 0;  
}



template <class InputStorageType, class OutputStorageType>
int Erosion<InputStorageType, OutputStorageType>::
Erode3Fast(const Image<InputStorageType>& src, 
           Image<OutputStorageType>& dest,
           bool Neighbor4) {
#ifdef BIAS_BOUNDS_CHECK
  if ((src.GetChannelCount() !=1) || (dest.GetChannelCount() !=1)) {
    BIASERR("Erosion<StorageType>::Erode3Fast()  only implemented for grey images");
    return -1;
  }
  if (src.GetPixelCount()<25) {
    BIASERR("Erosion<StorageType>::Erode3Fast(): src has less than 25 pixel");
    return -2;
  }
  if ( (src.GetHeight()<5) || (src.GetWidth() < 5)) {
    BIASERR("Erosion<StorageType>::Erode3Fast(): src has less than 5 cols or rows");
    return -3;
  }
  if (src.GetPixelCount() != dest.GetPixelCount()) {
    BIASERR("Erosion<StorageType>::Erode3Fast(): src and dest have different sizes");
    return -3;
  }
#endif
  // copy src to dest
  //  memcpy(dest.GetImageData() , src.GetImageData(), 
  //     src.GetPixelCount() * sizeof(StorageType));
  memset(dest.GetImageData(),0,src.GetPixelCount()*sizeof(OutputStorageType));
  register OutputStorageType *d=dest.GetImageDataArray()[1]+1;
  register const InputStorageType *p1=src.GetImageDataArray()[0];
  register const InputStorageType *p2=p1+1, *p3 = p2+1;
  register const InputStorageType *p4=src.GetImageDataArray()[1];
  register const InputStorageType *p5 = p4+1, *p6=p5+1;
  register const InputStorageType *p7 =src.GetImageDataArray()[2];
  register const InputStorageType *p8 = p7+1, *p9=p8+1;
  register const InputStorageType *last=&(src.GetImageData()[src.GetPixelCount()-1]);
  if (Neighbor4) {
    while (p8<last) {
      if (*p5 != 0) 
        if (*p2!=0) 
          if (*p4!=0)       
            if (*p6!=0)
              if (*p8!=0)         
                *d = OutputStorageType(*p5);
      p2++; p4++; p5++; p6++; p8++; d++;
    }
  } else {   
    while (p9<=last) {
      if (*p5 != 0) 
        if (*p1!=0) 
          if (*p2!=0)
            if (*p3!=0) 
              if (*p4!=0)
                if (*p6!=0) 
                  if (*p7!=0)
                    if (*p8!=0)
                      if (*p9!=0)
                        *d = OutputStorageType(*p5);
      p1++; p2++; p3++; p4++; p5++; p6++; p7++; p8++; p9++; d++;
    }
  }
  //// set border to zero
  // top and bottom
  register OutputStorageType *o1, *o9, *o2, *olast;
  o1 = dest.GetImageDataArray()[0];
  o9 = dest.GetImageDataArray()[dest.GetHeight()-1];
  olast=
    &(dest.GetImageData()[(dest.GetPixelCount()-1)*dest.GetChannelCount()]);
  while (o9<=olast) {
    *o1=0; *o9=0;
    o1++; o9++;
  }
  //  left and right
  register int offset = dest.GetWidth()*dest.GetChannelCount();
  o1 = dest.GetImageData();
  o2 = o1+offset-1;
  while (o2<=olast) {
    *o1=0; *o2=0;
    o1+=offset; o2+=offset;
  }
  return 0;
}

template <class InputStorageType, class OutputStorageType>
int Erosion<InputStorageType, OutputStorageType>::
Filter(const Image<InputStorageType>& src, 
       Image<OutputStorageType>& dst) {
  if (src.GetChannelCount()!=1) {
    BIASERR("Erosion only for 1 channel images");
    return -1;
  }
  if (_FilterBorderHandling==TBH_valid) {
    if (kernelSize_==3) {
      if ( (dst.IsEmpty()) || (! src.SamePixelAndChannelCount(dst)) )
        dst=src;
      Erode3Fast(src,dst,false);
      dst.GetROI()->SetCorners(1,1,dst.GetWidth()-2,dst.GetHeight()-2);
    } else {
      Erode(src,dst,kernelSize_);
      dst.GetROI()->SetCorners(1,1,dst.GetWidth()-2,dst.GetHeight()-2);
    } 
  } else if  (_FilterBorderHandling==TBH_same) {
    Image<InputStorageType> tmp;
    tmp.Init(src.GetWidth()+ int(kernelSize_/2)*2,
             src.GetHeight()+ int(kernelSize_/2)*2,1);
    tmp.FillImageWithConstValue(InputStorageType(0));
    tmp.GetROI()->SetCorners(kernelSize_/2 ,kernelSize_/2 ,
               tmp.GetWidth()-(kernelSize_/2), 
               tmp.GetHeight()-(kernelSize_/2));
    tmp.Paste2ROI(src);    
    dst.Release();
    Erode(tmp,dst,kernelSize_);
    dst.GetROI()->SetCorners(kernelSize_/2 ,kernelSize_/2 ,
               tmp.GetWidth() -(kernelSize_/2), 
               tmp.GetHeight()-(kernelSize_/2));
    dst.Cut2ROI();
  } else {
    BIASERR("borderhandling not implemnted/");
    return -1;
  }
  return 0;
}

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


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

namespace BIAS{
#define FILTER_INSTANTIATION_CLASS Erosion
#include "Filterinst.hh"
}