TukeyWindow.cpp

/* 
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003, 2004    (see file CONTACTS 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 "TukeyWindow.hh"

namespace BIAS {
  template <class InputStorageType, class OutputStorageType>
  TukeyWindow<InputStorageType, OutputStorageType>::TukeyWindow()
    : FilterNToN<InputStorageType,OutputStorageType>()
  {
    ratio_ = 0.5f;
    zeropad_ = 0;
  }

  template <class InputStorageType, class OutputStorageType>
  TukeyWindow<InputStorageType, OutputStorageType>::
  TukeyWindow(float ratio, unsigned int zeropad)
    : FilterNToN<InputStorageType,OutputStorageType>()
  {
    ratio_ = ratio;
    zeropad_ = zeropad;
  }

  template <class InputStorageType, class OutputStorageType>
  TukeyWindow<InputStorageType, OutputStorageType>::
  TukeyWindow(const TukeyWindow<InputStorageType, OutputStorageType>& other)
    : FilterNToN<InputStorageType, OutputStorageType>(other)
  {
    ratio_ = other.ratio_;
  }

  template <class InputStorageType, class OutputStorageType>
  TukeyWindow<InputStorageType, OutputStorageType>::~TukeyWindow() {
    // TODO
  }

  template <class InputStorageType, class OutputStorageType>
  int TukeyWindow<InputStorageType, OutputStorageType>::Filter(const Image<InputStorageType>& src, 
                     Image<OutputStorageType>& dst) {
    return FilterFloat(src, dst);
  }

  template <class InputStorageType, class OutputStorageType>
  int TukeyWindow<InputStorageType, OutputStorageType>::FilterInt(const Image<InputStorageType>& src, 
                        Image<OutputStorageType>& dst) {
    return FilterFloat(src, dst);
  }

  template <class InputStorageType, class OutputStorageType>
  int TukeyWindow<InputStorageType, OutputStorageType>::FilterFloat(const Image<InputStorageType>& src, 
                          Image<OutputStorageType>& dst) {
    if (ratio_ == 0.0) {
      if (src.GetStorageType() != dst.GetStorageType()) {
        BIASWARN("implicit type conversion");
      }
      dst = src;
      return 0;
    }
    unsigned int w = src.GetWidth();
    unsigned int h = src.GetHeight();
    unsigned int ch = src.GetChannelCount();
    if (dst.IsEmpty()) {
      dst.Init(w+2*zeropad_,h+2*zeropad_,ch);
    } else {
      dst.ReInit(w+2*zeropad_,h+2*zeropad_,ch);
    }
    if (zeropad_ != 0) {
      dst.FillImageWithConstValue((OutputStorageType)0);
    }
    if (ratio_ == 1.0) {
      // hmm TODO
      BIASERR("Not implemented!");
    } else {
      // compute idxes tapper, one, tapper
      float per = ratio_ / 2.0f;
      unsigned int wtl = (unsigned int)floor(per*(w-1));
      unsigned int wth = w-wtl-1;
      unsigned int htl = (unsigned int)floor(per*(h-1));
      unsigned int hth = h-htl-1;

      const InputStorageType **idaIn = src.GetImageDataArray();
      OutputStorageType **idaOut = dst.GetImageDataArray();
      
      for (unsigned int y=0;y<h;y++) {
        for (unsigned int x=0;x<w;x++) {
          for (unsigned int c=0;c<ch;c++) {
            OutputStorageType curval = (OutputStorageType) idaIn[y][x*ch+c];
            // [0 .. tl] .. [tl+1 ..th-tl-1] .. [th-tl .. th]
            if (x < wtl) {
              float idx = float(x)/float(wtl);
              curval = curval * (OutputStorageType)((1+cos((1.0f - idx) * M_PI)) / 2.0f);
            }
            if (x >= wth) {
              float idx = float(x-wth)/float(w-wth-1);
              curval = curval * (OutputStorageType)((1+cos(idx * M_PI)) / 2.0f);
            }
            if (y < htl) {
              float idx = float(y)/float(htl);
              curval = curval * (OutputStorageType)((1+cos((1.0f - idx) * M_PI)) / 2.0f);
            }
            if (y >= hth) {
              float idx = float(y-hth)/float(h-hth-1);
              curval = curval * (OutputStorageType)((1+cos(idx * M_PI)) / 2.0f);
            }
            idaOut[y+zeropad_][(x+zeropad_)*ch+c] = curval;
          }
        }
      }
      
      
    }
    return 0;
  }

  #define FILTER_INSTANTIATION_CLASS TukeyWindow
  #include "Filterinst.hh"
}