Parameters for taper computation. More...

#include <TaperParameters.h>

Inheritance diagram for GeopsyCore::TaperParameters:

Public Types
enum	Window { Rectangular, Hann, Hamming, Tukey, Cosine, Lanczos, Bartlett, Triangular, Gaussian, BartlettHann, Blackman, Nuttall, BlackmanHarris, BlackmanNuttall, FlatTop }
Public Member Functions
double	alpha () const
virtual void	collectKeywords (PARAMETERS_COLLECTKEYWORDS_ARGS)
virtual int	keywordCount (PARAMETERS_KEYWORDCOUNT_ARGS)
bool	reversed () const
void	setAlpha (double a)
void	setReversed (bool r)
void	setSigma (double s)
virtual bool	setValue (PARAMETERS_SETVALUE_ARGS)
void	setWindow (Window w)
void	setWindow (const QString &w)
double	sigma () const
	TaperParameters ()
	TaperParameters (const TaperParameters &o)
virtual QString	toString (PARAMETERS_TOSTRING_ARGS_DECL) const
Window	window () const
QString	windowString () const

Detailed Description

Parameters for taper computation.

The details about each window type is given at http://en.wikipedia.org/wiki/Window_function

Member Enumeration Documentation

enum GeopsyCore::TaperParameters::Window

Enumerator:

Rectangular
Hann
Hamming
Tukey
Cosine
Lanczos
Bartlett
Triangular
Gaussian
BartlettHann
Blackman
Nuttall
BlackmanHarris
BlackmanNuttall
FlatTop

                {Rectangular, Hann, Hamming, Tukey, Cosine, Lanczos, Bartlett, Triangular,
                 Gaussian, BartlettHann, Blackman, Nuttall, BlackmanHarris,
                 BlackmanNuttall, FlatTop};

Constructor & Destructor Documentation

GeopsyCore::TaperParameters::TaperParameters ( )

Defaults to Tuckey window or tapered cosine window. This was originally the only type of window available in Geopsy.

References _alpha, and Tukey.

  {
    _window=Tukey;
    _reversed=false;
    _alpha=0.5;
  }

GeopsyCore::TaperParameters::TaperParameters ( const TaperParameters & o )

References _alpha.

    : AbstractParameters()
  {
    _window=o._window;
    _reversed=o._reversed;
    _alpha=o._alpha;
  }

Member Function Documentation

double GeopsyCore::TaperParameters::alpha ( ) const [inline]

Referenced by GeopsyCore::TaperDelegate::apply(), GeopsyGui::TaperParameterWidget::setParameters(), and toString().

{return _alpha;}

void GeopsyCore::TaperParameters::collectKeywords ( PARAMETERS_COLLECTKEYWORDS_ARGS ) [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

References TRACE.

Referenced by GeopsyCore::FilterParameters::collectKeywords(), MonoStation::AbstractToolParameters::collectKeywords(), and ArrayCore::LinearFKParameters::collectKeywords().

  {
    TRACE;
    keywords.add(prefix+"WINDOW TYPE", this, 0);
    keywords.add(prefix+"WINDOW REVERSED", this, 1);
    keywords.add(prefix+"WINDOW SIGMA", this, 2);
    keywords.add(prefix+"WINDOW ALPHA", this, 3);
  }

int GeopsyCore::TaperParameters::keywordCount ( PARAMETERS_KEYWORDCOUNT_ARGS ) [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

  {
    return 5;
  }

bool GeopsyCore::TaperParameters::reversed ( ) const [inline]

Referenced by GeopsyCore::TaperDelegate::apply().

{return _reversed;}

void GeopsyCore::TaperParameters::setAlpha ( double a ) [inline]

Referenced by MonoStation::AbstractToold::AbstractToold(), MonoStation::AbstractToolParameters::AbstractToolParameters(), LinearFKActiveStationSignals::endPreprocess(), GeopsyGui::TaperParameterWidget::getParameters(), RealTimeStationSignals::setProcessed(), ArrayCore::SPACStationSignals::setProcessed(), ArrayCore::FKStationSignals::setProcessed(), and setValue().

{_alpha=a;}

void GeopsyCore::TaperParameters::setReversed ( bool r ) [inline]

Referenced by setValue().

{_reversed=r;}

void GeopsyCore::TaperParameters::setSigma ( double s ) [inline]

Referenced by GeopsyGui::TaperParameterWidget::getParameters(), and setValue().

{_sigma=s;}

bool GeopsyCore::TaperParameters::setValue ( PARAMETERS_SETVALUE_ARGS ) [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

References setAlpha(), setReversed(), setSigma(), setWindow(), and TRACE.

  {
    TRACE;
    switch(index) {
    case 0:
      setWindow(value);
      return true;
    case 1:
      setReversed(value=="y");
      return true;
    case 2:
      setSigma(value.toDouble());
      return true;
    case 3:
      setAlpha(value.toDouble());
      return true;
    default:
      return false;
    }
  }

void GeopsyCore::TaperParameters::setWindow ( Window w ) [inline]

Referenced by MonoStation::AbstractToolParameters::AbstractToolParameters(), GeopsyCore::DoubleSignal::decimateTime(), LinearFKActiveStationSignals::endPreprocess(), GeopsyGui::TaperParameterWidget::getParameters(), Process::run(), GeopsyCore::StationProcessSignals::setHighPassFilter(), RealTimeStationSignals::setProcessed(), ArrayCore::SPACStationSignals::setProcessed(), ArrayCore::FKStationSignals::setProcessed(), and setValue().

{_window=w;}

void GeopsyCore::TaperParameters::setWindow ( const QString & w )

References Bartlett, BartlettHann, Blackman, BlackmanHarris, BlackmanNuttall, Cosine, QGpCoreTools::endl(), FlatTop, Gaussian, Hamming, Hann, Lanczos, Nuttall, Rectangular, QGpCoreTools::tr(), Triangular, and Tukey.

  {
    w.toLower();
    if(!w.isEmpty()) {
      switch(w[0].unicode()) {
      case 'b':
        if(w=="bartlett") {
          _window=Bartlett;
          return;
        } else if(w=="bartlettHann") {
          _window=BartlettHann;
          return;
        } else if(w=="blackman"){
          _window=Blackman;
          return;
        } else if(w=="blackmanHarris") {
          _window=BlackmanHarris;
          return;
        } else if(w=="blackmanNuttall") {
          _window=BlackmanNuttall;
          return;
        }
        break;
      case 'c':
        if(w=="cosine") {
          _window=Cosine;
          return;
        }
        break;
      case 'f':
        if(w=="flattop") {
          _window=FlatTop;
          return;
        }
        break;
      case 'g':
        if(w=="gaussian") {
          _window=Gaussian;
          return;
        }
        break;
      case 'h':
        if(w=="hann") {
          _window=Hann;
          return;
        } else if(w=="hamming"){
          _window=Hamming;
          return;
        }
        break;
      case 'l':
        if(w=="lanczos") {
          _window=Lanczos;
          return;
        }
        break;
      case 'n':
        if(w=="nuttall") {
          _window=Nuttall;
          return;
        }
        break;
      case 'r':
        if(w=="rectangular") {
          _window=Rectangular;
          return;
        }
        break;
      case 't':
        if(w=="tukey") {
          _window=Tukey;
          return;
        } else if(w=="triangular"){
          _window=Triangular;
          return;
        }
        break;
      default:
        break;
      }
    }
    App::stream() << tr("Bad taper window '%1'.").arg(w) << endl;
  }

double GeopsyCore::TaperParameters::sigma ( ) const [inline]

Referenced by GeopsyCore::TaperDelegate::apply(), GeopsyGui::TaperParameterWidget::setParameters(), and toString().

{return _sigma;}

QString GeopsyCore::TaperParameters::toString ( PARAMETERS_TOSTRING_ARGS_DECL ) const [virtual]

Reimplemented from QGpCoreTools::AbstractParameters.

References alpha(), Blackman, Gaussian, QGpCoreTools::log(), sigma(), TRACE, Tukey, and windowString().

Referenced by GeopsyCore::FilterParameters::toString(), MonoStation::AbstractToolParameters::toString(), and ArrayCore::LinearFKParameters::toString().

  {
    TRACE;
    QString log;
    log+=prefix+"WINDOW TYPE="+windowString()+"\n";
    log+=prefix+"WINDOW REVERSED="+(_reversed ? "y" : "n")+"\n";
    switch(_window) {
    case Tukey:
    case Blackman:
      log+=prefix+"WINDOW ALPHA="+QString::number(alpha());
      break;
    case Gaussian:
      log+=prefix+"WINDOW SIGMA="+QString::number(sigma());
      break;
    default:
      break;
    }
    return log;
  }

Window GeopsyCore::TaperParameters::window ( ) const [inline]

Referenced by GeopsyCore::TaperDelegate::apply(), and GeopsyGui::TaperParameterWidget::setParameters().

{return _window;}

QString GeopsyCore::TaperParameters::windowString ( ) const

References Bartlett, BartlettHann, Blackman, BlackmanHarris, BlackmanNuttall, Cosine, FlatTop, Gaussian, Hamming, Hann, Lanczos, Nuttall, Rectangular, Triangular, and Tukey.

Referenced by toString().

  {
    switch(_window) {
    case Rectangular:
      break;
    case Hann:
      return "Hann";
    case Hamming:
      return "Hamming";
    case Tukey:
      return "Tuckey";
    case Cosine:
      return "Cosine";
    case Lanczos:
      return "Lanczos";
    case Bartlett:
      return "Bartlett";
    case Triangular:
      return "Triangular";
    case Gaussian:
      return "Gaussian";
    case BartlettHann:
      return "BartlettHann";
    case Blackman:
      return "Blackman";
    case Nuttall:
      return "Nuttall";
    case BlackmanHarris:
      return "BlackmanHarris";
    case BlackmanNuttall:
      return "BlackmanNuttall";
    case FlatTop:
      return "FlatTop";
    }
    return "Rectangular";
  }

Member Data Documentation

double GeopsyCore::TaperParameters::_alpha

Referenced by TaperParameters().

double GeopsyCore::TaperParameters::_sigma

The documentation for this class was generated from the following files:

GeopsyCore/TaperParameters.h
GeopsyCore/TaperParameters.cpp

Public Types

Public Member Functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation