/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkCombinedImageToImageMetricAdaptor.txx,v $
  Language:  C++
  Date:      $Date: 2003/09/10 14:30:08 $
  Version:   $Revision: 1.1 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkCombinedImageToImageMetricAdaptor_txx
#define __itkCombinedImageToImageMetricAdaptor_txx

#include "itkCombinedImageToImageMetricAdaptor.h"

namespace itk
{

template <typename TFixedImage, typename TMovingImage>
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::CombinedImageToImageMetricAdaptor()
{
  m_InternalMetrics.resize( 0 );
  m_MetricWeights.resize( 0 );
  m_NumberOfPixelsCounted = 0;
}

template <typename TFixedImage, typename TMovingImage>
void
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::SetMetric(
unsigned long idx,
MetricType * metric,
double weight )
{
  if( idx >= m_InternalMetrics.size() )
    {
    m_InternalMetrics.resize( idx + 1 );
    m_MetricWeights.resize( idx + 1 );
    } 
  m_InternalMetrics[idx] = metric;
  m_MetricWeights[idx] = weight;
}


template <typename TFixedImage, typename TMovingImage>
void
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::SetMetricWeight(
unsigned long idx,
double weight )
{
  if( idx >= m_InternalMetrics.size() )
    {
    m_InternalMetrics.resize( idx + 1 );
    m_MetricWeights.resize( idx + 1 );
    } 
  m_MetricWeights[idx] = weight;
}


template <typename TFixedImage, typename TMovingImage>
typename CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::MetricType *
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::GetMetric( unsigned long idx )
{
  if( idx >= m_InternalMetrics.size() )
    {
    return NULL;
    } 
  return ( m_InternalMetrics[idx].GetPointer() );
}

template <typename TFixedImage, typename TMovingImage>
double
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::GetMetricWeight( unsigned long idx )
{
  if( idx >= m_InternalMetrics.size() )
    {
    return 0.0;
    } 
  return ( m_MetricWeights[idx] );
}

template <typename TFixedImage, typename TMovingImage>
void
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::GetDerivative(
const ParametersType & parameters,
DerivativeType & derivative ) const
{

  // find the first non-null metric
  unsigned int k;
  const unsigned int numberOfParameters = this->GetNumberOfParameters();
  derivative = DerivativeType( numberOfParameters );

  // initial derivatives 
  derivative.Fill( 0.0 );

  for( k = 0; k < m_InternalMetrics.size(); k++ )
    {
    if ( m_InternalMetrics[k] )
      {
      // Delegate computation to the underlying Metric
      DerivativeType deriv;
      m_InternalMetrics[k]->GetDerivative( parameters, deriv );
      for( unsigned int j = 0; j < numberOfParameters; j++ )
        {
        derivative[j] += m_MetricWeights[k] * deriv[j];
        }
      }
    } // for each metric

}


template <typename TFixedImage, typename TMovingImage>
void
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::GetValueAndDerivative(
const ParametersType & parameters,
MeasureType & value,
DerivativeType & derivative ) const
{

  unsigned int k;
  const unsigned int numberOfParameters = this->GetNumberOfParameters();
  derivative = DerivativeType( numberOfParameters );

  // initial derivatives 
  derivative.Fill( 0.0 );
  value = 0.0;

  for( k = 0; k < m_InternalMetrics.size(); k++ )
    {
    if ( m_InternalMetrics[k] )
      {

      // Delegate computation to the underlying Metric
      DerivativeType deriv;
      MeasureType    v;
      m_InternalMetrics[k]->GetValueAndDerivative( parameters, v, deriv );

      value += m_MetricWeights[k] * v;

      for( unsigned int j = 0; j < numberOfParameters; j++ )
        {
        derivative[j] += m_MetricWeights[k] * deriv[j];
        }
      }

    } // for each metric

}


template <typename TFixedImage, typename TMovingImage>
typename CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::MeasureType
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::GetValue( const ParametersType & parameters ) const
{

  // initial derivatives 
  MeasureType value = 0.0;

  for( unsigned int k = 0; k < m_InternalMetrics.size(); k++ )
    {
    if ( m_InternalMetrics[k] )
      {
      // Delegate computation to the underlying Metric
      MeasureType    v;
      v = m_InternalMetrics[k]->GetValue( parameters );
      value += m_MetricWeights[k] * v;
      }
    } // for each metric

  return value;

}

template <typename TFixedImage, typename TMovingImage>
void
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::Initialize() throw ( ExceptionObject )
{
  for( unsigned int k = 0; k < m_InternalMetrics.size(); k++ )
    {
    if( m_InternalMetrics[k] )
      {

      m_InternalMetrics[k]->SetTransform( m_Transform );

      // Delegate to underlying metric
      m_InternalMetrics[k]->Initialize();  
    
      }
    }
}

template <typename TFixedImage, typename TMovingImage>
const unsigned long &
CombinedImageToImageMetricAdaptor<TFixedImage,TMovingImage>
::GetNumberOfPixelsCounted() const
{
   // find the first non-null metric
  unsigned int k;
  for( k = 0; k < m_InternalMetrics.size(); k++ )
    {
    if( m_InternalMetrics[k] )
      {
      return m_InternalMetrics[k]->GetNumberOfPixelsCounted();
      }
    }

  if ( k == m_InternalMetrics.size() )
    {
    itkExceptionMacro(<<"No non-null metric is present");
    }
  return m_NumberOfPixelsCounted;
}

} // end namespace itk
#endif