Dilation.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 "Dilation.hh"
#include "Base/Image/ImageConvert.hh"
#include <Base/Common/BIASpragma.hh>

#include <limits>

using namespace BIAS;
using namespace std;

template <class InputStorageType, class OutputStorageType>
Dilation<InputStorageType, OutputStorageType>::
Dilation(const Dilation<InputStorageType, OutputStorageType>& other)
{
  DilateLower_ = true;
}

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

  int Width = Source.GetWidth();
  int Height = Source.GetHeight();
  register int HalfKernelSize = (KernelSize - 1) / 2;
  OutputStorageType *Dest = NULL;
  register OutputStorageType **DestArray;
  register const InputStorageType **SourceArray = Source.GetImageDataArray();
  // if used in place temporary data is necessairy
  if ((void*)Source.GetImageData() == (void*)Destination.GetImageData()){
    Dest = new OutputStorageType[Height * Width];
    DestArray = new OutputStorageType*[Height];
    DestArray[0] = Dest;
    for (register int i=1; i< Height; i++) {
      DestArray[i] = DestArray[i-1] + Width;
    }
  } else {
    DestArray = Destination.GetImageDataArray();
  }
  // loop
  for (register int y = HalfKernelSize; 
       y < ((int)Source.GetHeight() - HalfKernelSize); y++){
    for (register int x = HalfKernelSize; 
         x < ((int)Source.GetWidth() - HalfKernelSize); x++) {
      DestArray[y][x] = 0;
      for (register int ky = -HalfKernelSize; ky <= HalfKernelSize; ky++)
        for (register int kx = -HalfKernelSize; kx <= HalfKernelSize; kx++)
          if (DilateLower_) {
            if (SourceArray[y+ky][x+kx]>DestArray[y][x])
              DestArray[y][x]=SourceArray[y+ky][x+kx];
          } else {
            if ((DestArray[y][x]==0 && SourceArray[y+ky][x+kx]>0) ||
                (SourceArray[y+ky][x+kx]<DestArray[y][x] && SourceArray[y+ky][x+kx]>0))
              DestArray[y][x]=SourceArray[y+ky][x+kx];
          }
    }     
  }

  if ((void*)Source.GetImageData() == (void*)Destination.GetImageData()){
    delete[] DestArray;
    Destination.Release();
    Destination.RedirectImageDataPointer(Dest);
  }
  // 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 Dilation<InputStorageType, OutputStorageType>::
Dilate3Fast(const Image<InputStorageType>& src, 
            const Image<InputStorageType>& orig,
            Image<OutputStorageType>& dest,
            bool Neighbor4) {  
#ifdef BIAS_DEBUG  
  if ((src.GetChannelCount() !=1) || (dest.GetChannelCount() !=1) ||
      (orig.GetChannelCount() !=1 ) ) {
    BIASERR("Dilation::Dilate3Fast()  only implemented for grey images");
    return -1;
  }
  if (src.GetPixelCount()<25) {
    BIASERR("Dilation::Dilate3Fast(): src has less than 25 pixel");
    return -2;
  }
  if ( (src.GetHeight()<5) || (src.GetWidth() < 5)) {
    BIASERR("Dilation::Dilate3Fast(): src has less than 5 cols or rows");
    return -3;
  }
  if (src.GetPixelCount() != dest.GetPixelCount()) {
    BIASERR("Dilation::Dilate3Fast(): src and dest have different sizes");
    return -3;
  }
#endif
  if (orig.GetStorageType()==dest.GetStorageType()) {
    // copy orig to dest
    memcpy(dest.GetImageData() , orig.GetImageData(), 
           orig.GetPixelCount()*sizeof(InputStorageType));
  } else {
    // have to convert
    ImageConvert::ConvertST(orig, dest, dest.GetStorageType());
  }
  // then delete the eroded background form src in dest
  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=0;
      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=0;
      p1++; p2++; p3++; p4++; p5++; p6++; p7++; p8++; p9++; d++;
    }
  }
  //// set border to zero
  // top and bottom
  register OutputStorageType *o1,*o2,*o9,*olast;
  o1 = dest.GetImageDataArray()[0];
  o9 = dest.GetImageDataArray()[dest.GetHeight()-1];
  olast=&(dest.GetImageData()[dest.GetPixelCount()-1]);
  while (o9<=olast) {
    *o1=0; *o9=0;
    o1++; o9++;
  }
  //  left and right
  register unsigned int offset = dest.GetWidth();
  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 Dilation<InputStorageType, OutputStorageType>::
Dilate3Fast(const Image<InputStorageType>& src, 
            Image<OutputStorageType>& dest,
            bool Neighbor4) {  
#ifdef BIAS_DEBUG  
  if ((src.GetChannelCount() !=1) || (dest.GetChannelCount() !=1) ) {
    BIASERR("Dilation::Dilate3Fast()  only implemented for grey images");
    return -1;
  }
  if (src.GetPixelCount()<25) {
    BIASERR("Dilation::Dilate3Fast(): src has less than 25 pixel");
    return -2;
  }
  if ( (src.GetHeight()<5) || (src.GetWidth() < 5)) {
    BIASERR("Dilation::Dilate3Fast(): src has less than 5 cols or rows");
    return -3;
  }
  if (src.GetPixelCount() != dest.GetPixelCount()) {
    BIASERR("Dilation::Dilate3Fast(): src and dest have different sizes");
    return -3;
  }
#endif
  
  // then delete the eroded background form src in dest
  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) {
      *d = OutputStorageType(255);
      if (*p2==0) 
        if (*p4==0)     
          if (*p5==0) 
            if (*p6==0)
              if (*p8==0)         
                *d = 0;
      p2++; p4++; p5++; p6++; p8++; d++;
    }
  } else {   
    while (p9<=last) {
      *d = OutputStorageType(255);
      if (*p1==0) 
        if (*p2==0)
          if (*p3==0) 
            if (*p4==0)
              if (*p5==0) 
                if (*p6==0) 
                  if (*p7==0)
                    if (*p8==0)
                      if (*p9==0)
                        *d=0;
      p1++; p2++; p3++; p4++; p5++; p6++; p7++; p8++; p9++; d++;
    }
  }
  //// set border to zero
  // top and bottom
  register OutputStorageType *o1,*o2,*o9,*olast;
  o1 = dest.GetImageDataArray()[0];
  o9 = dest.GetImageDataArray()[dest.GetHeight()-1];
  olast=&(dest.GetImageData()[dest.GetPixelCount()-1]);
  while (o9<=olast) {
    *o1=0; *o9=0;
    o1++; o9++;
  }
  //  left and right
  register unsigned int offset = dest.GetWidth();
  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 Dilation<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) {
      Image<InputStorageType> tmp(src);
      if ( (dst.IsEmpty()) || (! src.SamePixelAndChannelCount(dst)) )
        dst=src;   

      tmp.FillImageWithConstValue( InputStorageType(255) );

      Dilate3Fast(src,tmp,dst,false);
      dst.GetROI()->SetCorners(1,1,dst.GetWidth()-2,dst.GetHeight()-2);
    } else {
      Dilate(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() + (kernelSize_/2)*2,
             src.GetHeight()+ (kernelSize_/2)*2, 1);
    tmp.GetROI()->SetCorners(kernelSize_/2 ,kernelSize_/2 ,
               tmp.GetWidth()-(kernelSize_/2), 
               tmp.GetHeight()-(kernelSize_/2));
    tmp.Paste2ROI(src);    
    Dilate(tmp,dst,kernelSize_);
    dst.GetROI()->SetCorners(kernelSize_/2 ,kernelSize_/2 ,
               tmp.GetWidth() -(kernelSize_/2), 
               tmp.GetHeight()-(kernelSize_/2));
    dst.Cut2ROI();
  } else {
    BIASERR("Unknown border handling.");
    return -1;
  }
    
  return 0;
}

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

//////////////////////////////////////////////////////////////////////////
//                 instantiation
//////////////////////////////////////////////////////////////////////////
namespace BIAS{
#define FILTER_INSTANTIATION_CLASS Dilation
#include "Filterinst.hh"
}