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

#include <Base/Common/BIASpragma.hh>
#include <Base/Image/ImageConvert.hh>

using namespace BIAS;
using namespace std;

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

template <class InputStorageType, class OutputStorageType>
DeInterlace<InputStorageType, OutputStorageType>::
DeInterlace() : FilterNToN<InputStorageType, OutputStorageType>() 
{ 
  bUseEvenLines_ = true;
  bDoDownSamplingByTwo_ = false;
  eDeInterlaceType_ = BIAS_DI_22;
}

template <class InputStorageType, class OutputStorageType>
DeInterlace<InputStorageType, OutputStorageType>::
DeInterlace(const DeInterlace<InputStorageType, OutputStorageType>& other)
  : FilterNToN<InputStorageType, OutputStorageType>(),
    bUseEvenLines_(other.bUseEvenLines_),
    bDoDownSamplingByTwo_(other.bDoDownSamplingByTwo_),
    eDeInterlaceType_(other.eDeInterlaceType_)  
{
}

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

template <class InputStorageType, class OutputStorageType>
int DeInterlace<InputStorageType, OutputStorageType>::
Filter(const Image<InputStorageType>& src, Image<OutputStorageType>& dst)
{
  BIASCDOUT(D_FILTERBASE_CALLSTACK, "DeInterlace::Filter\n");
  int res = 0; 
 
  register double sum=0.0;
  const InputStorageType **psrc;
  OutputStorageType **pdst;
 
  register const int width = src.GetWidth();
  register const int height= src.GetHeight();
  register const int cc= src.GetChannelCount();
  //this is bad case just copy the even to odd lines or vice versa
  if(!bDoDownSamplingByTwo_){
    if(!dst.SamePixelAndChannelCount(src) || dst.IsEmpty()) {
      dst.Release();
      dst.Init(src.GetWidth(),src.GetHeight(),src.GetChannelCount(),
            src.GetStorageType(),src.IsInterleaved());
    }
    //go to beginnig of first row "0"
    psrc = src.GetImageDataArray();
    pdst = dst.GetImageDataArray();
    //use even lines 0,2,4,6...
    int line=0;
    if(bUseEvenLines_)
    {
      for(int i=0;i<height;i++){
        //even line
        if ( (i % 2) == 0)line = i;
        else line = i-1;
        for(int j=0;j<width;j++){
          for(int c=0;c<cc;c++){
            pdst[i][j*cc+c] = (OutputStorageType)psrc[line][j*cc+c];
          }
        }
      }
    }
    //use odd lines 1,3,5...
    else
    {
      for(int i=1;i<height-1;i++){
        //odd line
        if ( (i % 2) == 0)line = i+1;
        else line = i;
        for(int j=0;j<width;j++){
          for(int c=0;c<cc;c++){
            pdst[i][j*cc+c] = (OutputStorageType)psrc[line][j*cc+c];
          }
        }
      }
    }
  } //end !bDoDownSamplingByTwo_
  else{
    if(dst.GetWidth()!= src.GetWidth()/2 || 
       dst.GetHeight() != src.GetHeight()/2 || 
       dst.GetChannelCount() != src.GetChannelCount()|| 
       dst.IsEmpty())
    {
      dst.Release();
      dst.Init(src.GetWidth()/2,src.GetHeight()/2,
                src.GetChannelCount(), src.GetStorageType(), src.IsInterleaved());
     }
    //go to beginnig of first row "0"
    psrc = src.GetImageDataArray();
    pdst = dst.GetImageDataArray();
    //use even lines 0,2,4,6...
    if(bUseEvenLines_)
    {
      int jtwo = 0;
      int itwo = 0;
      for(int i=0;i<height/2;i++){
        for(int j=0;j<width/2;j++){
          jtwo = 2*j; itwo = 2*i;

          for(int c=0;c<cc;c++){

            switch(eDeInterlaceType_)
            {
              case BIAS_DI_121:
                if(j==0)//beginning of row
                  sum = (psrc[itwo][0*cc+c]+psrc[itwo][1*cc+c])/2;
                else if(j==(width/2)-1) // end of row
                  sum = (psrc[itwo][(jtwo-1)*cc+c]+psrc[itwo][jtwo*cc+c])/2;
                else // in between
                  sum = double( (psrc[itwo][(jtwo-1)*cc+c] + psrc[itwo][jtwo*cc+c]*2 + psrc[itwo][(jtwo+1)*cc+c])/4 );
                break;
              case BIAS_DI_22:
                if(j==0)//beginning of row
                  sum = (psrc[itwo][0*cc+c]+psrc[itwo][1*cc+c])/2;
                else    // rest of row
                  sum = (psrc[itwo][(jtwo-1)*cc+c]+psrc[itwo][jtwo*cc+c])/2;
                break;
            }
            pdst[i][j*cc+c] = (OutputStorageType)sum;
          }
        }
      }
    } 
    //use odd lines 1,3,5...
    else
    {
     int jtwo = 0;
     int itwo = 0;
     for(int i=1;i<height/2;i++)
      for(int j=0;j<width/2;j++){
        jtwo = 2*j; itwo = (2*i)-1;

        for(int c=0;c<cc;c++){

          switch(eDeInterlaceType_)
          {
            case BIAS_DI_121:
            if(j==0)//beginning of row
              sum = (psrc[itwo][0*cc+c]+psrc[itwo][1*cc+c])/2;
            else if(j==(width/2)-1) // end of row
              sum = (psrc[itwo][(jtwo-1)*cc+c]+psrc[itwo][jtwo*cc+c])/2;
            else // in between
              sum = (psrc[itwo][(jtwo-1)*cc+c] + psrc[itwo][jtwo*cc+c]*2 + psrc[itwo][(jtwo+1)*cc+c])/4;
          break;
          case BIAS_DI_22:
            if(j==0)//beginning of row
              sum = (psrc[itwo][0*cc+c]+psrc[itwo][1*cc+c])/2;
            else    // rest of row
              sum = (psrc[itwo][(jtwo-1)*cc+c]+psrc[itwo][jtwo*cc+c])/2;
            break;
          }
          pdst[i][j*cc+c] = (OutputStorageType)sum;
        }
      }
    }
  } //end downsampling != 1.0
  return res;
}

template <class InputStorageType, class OutputStorageType>
int DeInterlace<InputStorageType, OutputStorageType>::
FilterInt(const Image<InputStorageType>& src, Image<OutputStorageType>& dst)
{
  BIASERR("Unimplemented interface, calling generic Filter");
  return Filter(src, dst);
}

template <class InputStorageType, class OutputStorageType>
int DeInterlace<InputStorageType, OutputStorageType>::
FilterFloat(const Image<InputStorageType>& src, Image<OutputStorageType>& dst)
{
  BIASERR("Unimplemented interface, calling generic Filter");
  return Filter(src, dst);
}


template <class InputStorageType, class OutputStorageType> 
int DeInterlace<InputStorageType, OutputStorageType>::
FilterColorImg(const Image<InputStorageType>& src,
               Image<OutputStorageType>& dst) {


  Image<InputStorageType> srcCopy,temp;

  int width = src.GetWidth();
  int height = src.GetHeight();
  
  // use planar image in order to apply deinterlace filter seperately to each channel for now
  if (!((src.GetColorModel() == ImageBase::CM_RGB) && src.IsPlanar())) {
    temp = src;
    ImageConvert::Convert(temp, srcCopy, ImageBase::CM_RGB, true);
  } else {
    srcCopy = src;
  }

/*
  if (src.GetColorModel() != ImageBase::CM_RGB) {
    BIASERR("ColorModel is not CM_RGB");
    return -1;
  }

  if (!src.IsPlanar()) {
    ImageConvert::ToPlanar(src,srcCopy);
  } else {
    srcCopy = src; // ok?
  }
*/  
  Image<InputStorageType> red(width, height, 1);
  Image<OutputStorageType> redG(width, height, 1);
  Image<InputStorageType> green(width, height, 1);
  Image<OutputStorageType> greenG(width, height, 1);
  Image<InputStorageType> blue(width, height, 1);
  Image<OutputStorageType> blueG(width, height, 1);
  
  red.GetChannel(srcCopy, 0);
  green.GetChannel(srcCopy, 1);
  blue.GetChannel(srcCopy, 2);

  Filter(red, redG);
  Filter(green, greenG);
  Filter(blue, blueG);

  width = redG.GetWidth();
  height = redG.GetHeight();

  dst =  Image<OutputStorageType>(width, height, 3, true);
  for (int i =0; i < width; i++) {
    for (int j=0; j < height; j++) {
      dst.SetPixel(redG.PixelValue(i, j), i, j, 0);
      dst.SetPixel(greenG.PixelValue(i, j), i, j, 1);
      dst.SetPixel(blueG.PixelValue(i, j), i, j, 2);
    }
  }

  return 0 ;
}




template <class InputStorageType, class OutputStorageType>
void DeInterlace<InputStorageType, OutputStorageType>::
SetUseEvenLines(bool bEvenLines)
{
  bUseEvenLines_ = bEvenLines;
}

template <class InputStorageType, class OutputStorageType>
void DeInterlace<InputStorageType, OutputStorageType>::
SetDeInterlaceType(BIAS_DEINTERLACE_TYPE type)
{
 eDeInterlaceType_ = type;
}


template <class InputStorageType, class OutputStorageType>
void DeInterlace<InputStorageType, OutputStorageType>::
SetDownSamplingByTwo(bool bDoDownSamplingByTwo )
{
  bDoDownSamplingByTwo_ = bDoDownSamplingByTwo;
}

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