ScaleNormalizer.cpp

Go to the documentation of this file.

#include <openmodeller/ScaleNormalizer.hh>
#include <openmodeller/Sampler.hh>
#include <openmodeller/Log.hh>

using namespace std;

/*******************/
/*** constructor ***/
ScaleNormalizer::ScaleNormalizer( Scalar min, Scalar max, bool useLayerAsRef ) :
  _min( min ),
  _max( max ),
  _use_layer_as_ref( useLayerAsRef ),
  _offsets(),
  _scales()
{
}

/*******************/
/*** constructor ***/
ScaleNormalizer::ScaleNormalizer() :
  _min( 0.0 ),
  _max( 1.0 ),
  _use_layer_as_ref( true ),
  _offsets(),
  _scales()
{
}

/******************/
/*** destructor ***/
ScaleNormalizer::~ScaleNormalizer() {}

/****************/
/*** get Copy ***/
Normalizer * ScaleNormalizer::getCopy() {

  return new ScaleNormalizer( *this );
}

/*****************************/
/*** compute Normalization ***/
void ScaleNormalizer::computeNormalization( const ReferenceCountedPointer<const SamplerImpl>& samplerPtr ) {

  int dim = samplerPtr->numIndependent();
  Sample smin(dim), smax(dim);

  bool get_minmax_from_sampler = true;

  if ( _use_layer_as_ref ) {

    Log::instance()->debug( "Using min/max from layer as reference for normalization.\n");

    EnvironmentPtr envPtr = samplerPtr->getEnvironment();

    if ( envPtr ) { 

      envPtr->getMinMax( &smin, &smax );

      get_minmax_from_sampler = false;
    }
    else {

      Log::instance()->warn( "Sampler has no environment. ScaleNormalizaer will get min/max directly from samples instead.\n");
    }
  }
  else {

    Log::instance()->debug( "Using min/max from input samples as reference for normalization.\n");
  }

  if ( get_minmax_from_sampler ) {

    samplerPtr->getMinMax( &smin, &smax );
  }

  _scales.resize(dim);
  _offsets.resize(dim);

  for ( int i = 0; i < dim; ++i ) {

    if ( smax[i] == smin[i] ) {

      Log::instance()->warn( "Min/max values for variable %d are the same during normalization!\n", (i+1));

      // Avoid zero division
      _scales[i] = 1.0;
    }
    else {

      _scales[i] = (_max - _min) / (smax[i] - smin[i]);
    }

    _offsets[i] = _min - _scales[i] * smin[i];
  }
}

/*****************/
/*** normalize ***/
void ScaleNormalizer::normalize( Sample * samplePtr ) {

  if ( samplePtr->size() != 0 ) {

    *samplePtr *= _scales;
    *samplePtr += _offsets;
  }
}

/*************************/
/*** get configuration ***/
ConfigurationPtr ScaleNormalizer::getConfiguration() const {

  ConfigurationPtr config( new ConfigurationImpl("Normalization") );

  config->addNameValue( "Class", "ScaleNormalizer" );

  int temp_val = (_use_layer_as_ref) ? 1 : 0;

  config->addNameValue( "UseLayerAsRef", temp_val );

  config->addNameValue( "Min", _min );
  config->addNameValue( "Max", _max );
  
  config->addNameValue( "Offsets", _offsets );
  config->addNameValue( "Scales", _scales );

  return config;
}

/*************************/
/*** set configuration ***/
void ScaleNormalizer::setConfiguration( const ConstConfigurationPtr &config ) {

  int temp_val = config->getAttributeAsInt( "UseLayerAsRef", 1 );

  _use_layer_as_ref = (temp_val == 1) ? true : false;

  _min = config->getAttributeAsDouble( "Min", 0.0 );
  _max = config->getAttributeAsDouble( "Max", 1.0 );

  _offsets = config->getAttributeAsSample( "Offsets" );
  _scales  = config->getAttributeAsSample( "Scales" );
}