tools.hh

#ifndef __TOOLS_H
#define __TOOLS_H

#include <boost/shared_ptr.hpp>
#include <boost/multi_array.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <complex>
#include <functional>
#include <mimas/mm_image.h>
#include <mimas/mm_image_input.h>
#include <mimas/mm_multi_array_op.h>
#include <mimas/mm_rgba.h>
#include <popt.h>
#include <string>

// #define MMUSEOSMESA

#ifndef MMUSEOSMESA
#define GLX_GLXEXT_PROTOTYPES
#include <GL/glx.h>
#include <X11/Xlib.h>
#else
#include <GL/osmesa.h>
#endif

template< typename T >
mimas::mm_image< T > multi_array_to_mm_image
   ( const boost::multi_array< T, 2 > &x );

template< typename T >
boost::multi_array< T, 2 > mm_image_to_multi_array
   ( const mimas::mm_image< T > &x );

template< typename T >
struct fast_sqr: public std::unary_function< T, int >
{
  fast_sqr(void) {
    for ( short int i=0; i<(signed)table.size(); i++ )
      table[i] = (int)i * i;
  }
  int operator()( const T &x ) const {
    assert( x > -(signed)table.size() && x < (signed)table.size() );
    return table[ x < 0 ? -x : x ];
  }
  boost::array< int, 512 > table;
};

template< typename T >
struct rand_function: public std::unary_function< T, int >
{
  rand_function(void) { srand( time( 0 ) ); }
  int operator()( const T &size ) const {
    return (int)( rand() / ( RAND_MAX + 1.0 ) * size );
  }
};

template< typename T >
struct _fastsqr: public std::unary_function< T, int > 
{
  int operator()( const T &x ) const { return f( x ); }
  fast_sqr< T > f;
};

template< typename T >
struct _sqr: public std::unary_function< T, T > 
{
  T operator()( const T &x ) const { return x * x; }
};

template< typename T >
struct _sqrt: public std::unary_function< T, T > 
{
  T operator()( const T &x ) const { return sqrt( x ); }
};

template< typename T >
struct _conj: public std::unary_function< T, T >
{
  T operator()( const T &x ) const
  { return conj( x ); }
};

template< typename T >
struct _tobinary: public std::unary_function< T, bool > {
  bool operator()( const T &x ) const
  { return x > 0 ? true : false; }
};

template< typename T >
struct _touchar: public std::unary_function< T, unsigned char > {
  unsigned char operator()( const T &x ) const
  { return static_cast< unsigned char >( x ); }
};

template< typename T >
struct _todouble: public std::unary_function< T, double > {
  double operator()( const T &x ) const
  { return static_cast< double >( x ); }
};

template< typename T >
struct _tobw: public std::unary_function< T,
                                          mimas::mm_rgba< unsigned char > > {
  mimas::mm_rgba< unsigned char > operator()( const T &x ) const
  { return
      x ? mimas::mm_rgba< unsigned char >( 0, 255, 0 ) :
          mimas::mm_rgba< unsigned char >( 0, 0, 0 ); }
};

template< typename T >
struct _tobw2: public std::unary_function< T,
                                           unsigned char > {
  unsigned char operator()( const T &x ) const
  { return x ? 255 : 0; }
};

mimas::mm_image< short int > gradX
  ( const mimas::mm_image< unsigned char > &m );
mimas::mm_image< short int > gradY
  ( const mimas::mm_image< unsigned char > &m );
template< typename T >
mimas::mm_image< T > load_image( const std::string &fileName );
mimas::mm_image< bool > edgeDetect
  ( const mimas::mm_image< unsigned char > &m,
    short int threshold );
mimas::mm_image< unsigned char > down_sample
  ( const mimas::mm_image< unsigned char > &x, int rate, int fringe );
mimas::mm_image< bool > gradientLevels
  ( const mimas::mm_image< unsigned char > &image,
  short int minGradient );
boost::numeric::ublas::vector< int > center
  ( const std::vector< boost::numeric::ublas::vector< int > > &points );
std::vector< boost::numeric::ublas::vector< int > > featurePoints
  ( const mimas::mm_image< bool > &binary );
std::vector< boost::numeric::ublas::vector< int > > subtractOffset
  ( const std::vector< boost::numeric::ublas::vector< int > > &points,
    const boost::numeric::ublas::vector< int > &offset );

std::vector< boost::numeric::ublas::vector< int > > scalePoints
  ( const std::vector< boost::numeric::ublas::vector< int > > &points,
    double scale );

boost::shared_ptr< mimas::mm_image_input< mimas::mm_rgba< unsigned char > > >
   open_image_input
   ( int selectedInput, poptContext &optCon,
     int gstreamerSHMKey, int gstreamerSEMKey,
     const char *device, int channel,
     int width, int height, int brightness, int contrast,
     int shutter, int gain, int balance );

#include "tools.tcc"

#endif

---