filter.h

Go to the documentation of this file.

#ifndef FILTER_H
#define FILTER_H

#include <vector>
#include "mimasexception.h"
#include "image.h"

namespace mimas {
class property_image;

template<typename T>
class filter
{
 public:
    //just a namespace used to tie all the filters together
    //filters operate on images

protected:
    void  filterRows(image<T> &input, image<T>&output,
                    std::vector<double> * prof1d); 
    void  filterCols(image<T> &input, image<T>&output,
                    std::vector<double> * prof1d); 
          //<< convolution functions go here! >>

public:
    // destructor
    virtual ~filter() {}
    //interface
    virtual void filterIt( image<T>& input )=0; 
    virtual void filterTo( image<T>& input, image<T>& output)=0; 

    //static filters (ie no local vars, can be called without
    //an instance of this class)
    static void gradX( const image<T>& input, image<T>& output ); 
    static void gradY( const image<T>& input, image<T>& output ); 
    static void nonMaximaSuppression( const image<T>& gradx,
                                      const image<T>& grady,
                                      const image<T>& gradsq,
                                      double threshold,
                                      property_image& output )
      throw (mimasexception); 
};

//----------- basic common functionality. should add convolutions --------------

template<typename T>
void filter<T>::filterRows( image<T> &input, image<T>& output,
                               std::vector<double>* prof1d )
{
    double  norm=0;
    int   mp, w=input.getWidth();
    boost::shared_array< T > row( new T[input.getWidth()] );
    double  v;
    int   nx;

    if ( &output != &input )
      output.init( input.getWidth(), input.getHeight());

    for(int i=0;i<(signed)prof1d->size();++i)
  norm+=(*prof1d)[i];

    if (norm==0)  return;
    mp = prof1d->size()/2;

    for(int y=0;y<input.getHeight();++y)
    {
        //stumeikle20030304 break the operation into 3 parts now...
  //first bit...
  for(int x=0;x<mp;++x)
  {
      v=0;

      nx=x-mp;
      for(int i=0;i<(signed)prof1d->size();++i,++nx)
      {
    if (nx>0 && nx<w)
    {
        v+=input.pixel(nx,y) * (*prof1d)[i];
    }
      }
      v/=norm;
      row[x] = (T)v;
  }

  //main bit..
  for(int x=mp;x<(w-mp);++x)
  {
      v=0;

      nx=x-mp;
      for(int i=0;i<(signed)prof1d->size();++i,++nx)
    v+=input.pixel(nx,y) * (*prof1d)[i];
      v/=norm;
      row[x] = (T)v;
  }

  //end bit
  for(int x=w-mp;x<w;++x)
  {
      v=0;

      nx=x-mp;
      for(int i=0;i<(signed)prof1d->size();++i,++nx)
      {
    if (nx>0 && nx<w)
    {
        v+=input.pixel(nx,y) * (*prof1d)[i];
    }
      }
      v/=norm;
      row[x] = (T)v;
  }

  //copy the row to the output
   copy( row.get(), row.get() + input.getWidth(), output.rawData()[y].begin() );
    }
}


template<typename T>
void filter<T>::filterCols( image<T> &input, image<T>& output,
                               std::vector<double>* prof1d )
{
    double  norm=0;
    int   i,mp, h=input.getHeight(),y;
    boost::shared_array< T > col( new T[input.getHeight()] );
    double  v=0;
    int     ny;


    if ( &output != &input )
      output.init( input.getWidth(), input.getHeight());

    for(i=0;i<(signed)prof1d->size();++i)
  norm+=(*prof1d)[i];

    if (norm==0)  return;
    mp = prof1d->size()/2;

    for(int x=0;x<input.getWidth();++x)
    {
  for(y=0;y<h;++y)
      col[y]=input.pixel(x,y);

  //you could use the tina optimations here but they're too :-*
  //break this into 3 parts now. stumeikle 20030304
  //the start...
  for(y=0;y<mp;++y)
  {
      v=0;

      ny=y-mp;
      for(i=0;i<(signed)prof1d->size();++i,++ny)
      {
    if (ny>0 && ny<h)
        v+=input.pixel(x,ny) * (*prof1d)[i];
      }
      v/=norm;
      col[y] = (T)v;
  }

  //middle part
  for(y=mp;y<(h-mp);++y)
  {
      v=0;

      ny=y-mp;
      for(i=0;i<(signed)prof1d->size();++i,++ny)
        v+=input.pixel(x,ny) * (*prof1d)[i];
      v/=norm;
      col[y] = (T)v;
  }

  //end bit
  for(y=(h-mp);y<h;++y)
  {
      v=0;

      ny=y-mp;
      for(i=0;i<(signed)prof1d->size();++i,++ny)
      {
    if (ny>0 && ny<h)
        v+=input.pixel(x,ny) * (*prof1d)[i];
      }
      v/=norm;
      col[y] = (T)v;
  }

  for(y=0;y<h;++y)
      output.pixel(x,y)=col[y];
    }

}

}

#include "filter_grad.h"
#include "filter_nonmaxsup.h"

#endif

---