Detector.h

Go to the documentation of this file.

// Detector.h
//////////////////////////////////////////////////////////////////////
//          (c) Copyright 2000-2002 Brown Deer Technology, LLC.     
//                        All rights reserved.                   
//////////////////////////////////////////////////////////////////////

#ifndef DETECTOR_H
#define DETECTOR_H

#include "Rtrsmra.h"
#include "Darray.h"
#include "Fuzzy.h"

template< class Rtrsmra_t, class Logic_t >
class DetectorBase {
   public:

      typedef typename Rtrsmra_t::DataType DataType;
      typedef Logic_t LogicType;
      typedef Darray<Logic_t> DarrayType;

      DetectorBase( Rtrsmra_t& x ) { 
         _mmax = x.mmax(); 
         _x = &x; 
         _ta = new DataType[ _mmax + 1 ];
         _ha = new int[ _mmax + 1 ];
      }

      virtual ~DetectorBase() { 
        _x = 0; 
        if ( _ta != 0 ) { delete [] _ta; _ta = 0; }
        if ( _ha != 0 ) { delete [] _ha; _ha = 0; }
      }

      DarrayType Detectlt( const DataType* ta) {
         (*_x).detectlt( ta, _ha );
         Darray<Logic_t> da( _mmax + 1 );
         map( _ha, da );
         return da;
      }

      DarrayType Detectle(const DataType* ta) {
         (*_x).detectle( ta, _ha );
         Darray<Logic_t> da( _mmax + 1 );
         map( _ha, da );
         return da;
      }

      DarrayType Detectgt(const DataType* ta) {
         (*_x).detectgt(ta,_ha);
         Darray<Logic_t> da(_mmax+1);
         map(_ha,da);
         return da;
      }

      DarrayType Detectge(const DataType* ta) {
         (*_x).detectge(ta,_ha);
         Darray<Logic_t> da(_mmax+1);
         map(_ha,da);
         return da;
      }

      DarrayType Detectlt(const DataType t) {
         for(int m=0;m<=_mmax;m++) _ta[m]=t;
         (*_x).detectlt(_ta,_ha);
         Darray<Logic_t> da(_mmax+1);
         map(_ha,da);
         return da;
      }

      DarrayType Detectle(const DataType t) {
         for(int m=0;m<=_mmax;m++) _ta[m]=t;
         (*_x).detectle(_ta,_ha);
         Darray<Logic_t> da(_mmax+1);
         map(_ha,da);
         return da;
      }

      DarrayType Detectgt(const DataType t) {
         for(int m=0;m<=_mmax;m++) _ta[m]=t;
         (*_x).detectgt(_ta,_ha);
         Darray<Logic_t> da(_mmax+1);
         map(_ha,da);
         return da;
      }

      DarrayType Detectge(const DataType t) {
         for(int m=0;m<=_mmax;m++) _ta[m]=t;
         (*_x).detectge(_ta,_ha);
         Darray<Logic_t> da(_mmax+1);
         map(_ha,da);
         return da;
      }

      virtual void map(const int* ha, DarrayType& da) {
         for(int m=0;m<=_mmax;m++) da[m]=float(ha[m]);
      }

   protected:
      DataType* _ta;
      int* _ha;
      int _mmax;
      Rtrsmra_t* _x;
};

template<class Rtrsmra_t, class Logic_t>
class Detector : public DetectorBase<Rtrsmra_t,Logic_t> {
   public:
      Detector(Rtrsmra_t& x) : DetectorBase<Rtrsmra_t,Logic_t>(x) {}
};

template<class Logic_t>
class Detector< Rtrsmra<float,array>, Logic_t> 
  : public DetectorBase< Rtrsmra<float,array>, Logic_t > {
   public:
      typedef typename
        DetectorBase< Rtrsmra<float,array>, Logic_t >::DarrayType DarrayType;
      Detector( Rtrsmra<float,array>& x) 
        : DetectorBase< Rtrsmra<float,array>,Logic_t>(x) {}
      void map(const int* ha, DarrayType& da) {
         for(int m=0;m<=_mmax;m++) da[m]=float(ha[m])/float((*_x).amax()+1);
      }
};

template<class Logic_t>
class Detector< Rtrsmra<double,array>, Logic_t> 
  : public DetectorBase< Rtrsmra<double,array>, Logic_t > {
   public:
      typedef typename
        DetectorBase< Rtrsmra<double,array>, Logic_t >::DarrayType DarrayType;
      Detector( Rtrsmra<double,array>& x) 
        : DetectorBase< Rtrsmra<double,array>,Logic_t>(x) {}
      void map(const int* ha, DarrayType& da) {
         for(int m=0;m<=_mmax;m++) da[m]=float(ha[m])/float((*_x).amax()+1);
      }
};

template<class Detector_T, class Thresh_T>
typename Detector_T::DarrayType 
  operator<( Detector_T& d, Thresh_T& t ) { return d.Detectlt(t); }

template<class Detector_T, class Thresh_T>
typename Detector_T::DarrayType 
  operator<=( Detector_T& d, Thresh_T& t ) { return d.Detectle(t); }

template<class Detector_T, class Thresh_T>
typename Detector_T::DarrayType 
  operator>( Detector_T& d, Thresh_T& t ) { return d.Detectgt(t); }

template<class Detector_T, class Thresh_T>
typename Detector_T::DarrayType 
  operator>=( Detector_T& d, Thresh_T& t ) { return d.Detectge(t); }

#endif

---