/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkConvertPixelBuffer_hxx
#define itkConvertPixelBuffer_hxx
#include "itkConvertPixelBuffer.h"

#include "itkRGBPixel.h"
#include "itkDefaultConvertPixelTraits.h"
#include <cstddef>


namespace itk
{

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
template <typename UComponentType>
typename DisableIfC<
  NumericTraits< UComponentType >::IsInteger, UComponentType>::Type
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::DefaultAlphaValue()
{
  return NumericTraits<UComponentType>::One;
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
template <typename UComponentType>
typename EnableIfC<
  NumericTraits< UComponentType >::IsInteger, UComponentType>::Type
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::DefaultAlphaValue()
{
  return NumericTraits<UComponentType>::max();
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::Convert(InputPixelType *inputData,
          int inputNumberOfComponents,
          OutputPixelType *outputData, size_t size)
{
  switch ( OutputConvertTraits::GetNumberOfComponents() )
    {
    // output number of components is 1
    case 1:
      {
      switch ( inputNumberOfComponents )
        {
        case 1:
          ConvertGrayToGray(inputData, outputData, size);
          break;
        case 3:
          ConvertRGBToGray(inputData, outputData, size);
          break;
        case 4:
          ConvertRGBAToGray(inputData, outputData, size);
          break;
        default:
          ConvertMultiComponentToGray(inputData, inputNumberOfComponents,
                                      outputData, size);
          break;
        }
      break;
      }
    // handle the complex case
    case 2:
      {
      switch ( inputNumberOfComponents )
        {
        case 1:
          ConvertGrayToComplex(inputData, outputData, size);
          break;
        case 2:
          ConvertComplexToComplex(inputData, outputData, size);
          break;
        default:
          ConvertMultiComponentToComplex(inputData, inputNumberOfComponents, outputData, size);
          break;
        }
      break;
      }

    // output number of components is 3 RGB
    case 3:
      {
      switch ( inputNumberOfComponents )
        {
        case 1:
          ConvertGrayToRGB(inputData, outputData, size);
          break;
        case 3:
          ConvertRGBToRGB(inputData, outputData, size);
          break;
        case 4:
          ConvertRGBAToRGB(inputData, outputData, size);
          break;
        default:
          ConvertMultiComponentToRGB(inputData, inputNumberOfComponents,
                                     outputData, size);
        }
      break;
      }
    // output number of components is 4 RGBA
    case 4:
      {
      switch ( inputNumberOfComponents )
        {
        case 1:
          ConvertGrayToRGBA(inputData, outputData, size);
          break;
        case 3:
          ConvertRGBToRGBA(inputData, outputData, size);
          break;
        case 4:
          ConvertRGBAToRGBA(inputData, outputData, size);
          break;
        default:
          ConvertMultiComponentToRGBA(inputData, inputNumberOfComponents,
                                      outputData, size);
        }
      break;
      }
    // output number of components is 6 (SymmetricSecondRankTensor)
    case 6:
      {
      switch ( inputNumberOfComponents )
        {
        case 6:
          ConvertTensor6ToTensor6(inputData, outputData, size);
          break;
        case 9:
          ConvertTensor9ToTensor6(inputData, outputData, size);
          break;
        default:
          itkGenericExceptionMacro("No conversion available from "
                                   << inputNumberOfComponents
                                   << " components to: 6 components");
          break;
        }
      break;
      }
    default:
      itkGenericExceptionMacro("No conversion available from "
                               << inputNumberOfComponents
                               << " components to: "
                               <<  OutputConvertTraits::GetNumberOfComponents()
                               << " components");
      break;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertGrayToGray(InputPixelType *inputData,
                    OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData++,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    inputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertRGBToGray(InputPixelType *inputData,
                   OutputPixelType *outputData, size_t size)
{
  // Weights convert from linear RGB to CIE luminance assuming a
  // modern monitor.  See Charles Pontyon's Colour FAQ
  // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html
  // NOTE: The scale factors are converted to whole numbers for precision

  InputPixelType *endInput = inputData + size * 3;

  while ( inputData != endInput )
    {
    auto val = static_cast< OutputComponentType >(
      ( 2125.0 * static_cast< OutputComponentType >( *inputData )
        + 7154.0 * static_cast< OutputComponentType >( *( inputData + 1 ) )
        + 0721.0 * static_cast< OutputComponentType >( *( inputData + 2 ) ) ) / 10000.0 );
    inputData += 3;
    OutputConvertTraits::SetNthComponent(0, *outputData++, val);
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertRGBAToGray(InputPixelType *inputData,
                    OutputPixelType *outputData, size_t size)
{
  // Weights convert from linear RGB to CIE luminance assuming a
  // modern monitor.  See Charles Pontyon's Colour FAQ
  // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html
  // NOTE: The scale factors are converted to whole numbers for
  // precision
  InputPixelType *endInput = inputData + size * 4;
  double maxAlpha(DefaultAlphaValue<InputPixelType>());
  //
  // To be backwards campatible, if the output pixel type
  // isn't a short or char type, don't fix the problem.
  if(sizeof(*outputData) > 2)
    {
    maxAlpha = 1.0;
    }
  while ( inputData != endInput )
    {
    // this is an ugly implementation of the simple equation
    // greval = (.2125 * red + .7154 * green + .0721 * blue) / alpha
    //
    double tempval =
      ((2125.0 * static_cast< double >( * inputData)
        + 7154.0 * static_cast< double >( *( inputData + 1 ))
        + 0721.0 * static_cast< double >( *( inputData + 2 ))) / 10000.0)
      * static_cast< double >(*( inputData + 3))
      / maxAlpha;
    inputData += 4;
    auto val = static_cast< OutputComponentType >( tempval );
    OutputConvertTraits::SetNthComponent(0, *outputData++, val);
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertMultiComponentToGray(InputPixelType *inputData,
                              int inputNumberOfComponents,
                              OutputPixelType *outputData, size_t size)
{
  //
  // To be backwards campatible, if the output pixel type
  // isn't a short or char type, don't fix the problem.
  double maxAlpha(DefaultAlphaValue<InputPixelType>());
  if(sizeof(*outputData) > 2)
    {
    maxAlpha = 1.0;
    }
  // 2 components assumed intensity and alpha
  if ( inputNumberOfComponents == 2 )
    {
    InputPixelType *endInput = inputData + size * 2;
    while ( inputData != endInput )
      {
      OutputComponentType val =
        static_cast< OutputComponentType >( *inputData )
        * static_cast< OutputComponentType >( *( inputData + 1 )
                                              / maxAlpha);
      inputData += 2;
      OutputConvertTraits::SetNthComponent(0, *outputData++, val);
      }
    }
  // just skip the rest of the data
  else
    {
    // Weights convert from linear RGB to CIE luminance assuming a
    // modern monitor.  See Charles Pontyon's Colour FAQ
    // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html
    // NOTE: The scale factors are converted to whole numbers for
    // precision
    ptrdiff_t       diff = inputNumberOfComponents - 4;
    InputPixelType *endInput = inputData + size * (size_t)inputNumberOfComponents;
    while ( inputData != endInput )
      {
      double tempval =
        ((2125.0 * static_cast< double >( *inputData )
          + 7154.0 * static_cast< double >( *( inputData + 1 ) )
          + 0721.0 * static_cast< double >( *( inputData + 2 ) ) ) / 10000.0)
        * static_cast< double >(*( inputData + 3 ))
        / maxAlpha;
    inputData += 4;
    auto val = static_cast< OutputComponentType >( tempval );
    OutputConvertTraits::SetNthComponent(0, *outputData++, val);
    inputData += diff;
      }
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertGrayToRGB(InputPixelType *inputData,
                   OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    inputData++;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertRGBToRGB(InputPixelType *inputData,
                  OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size * 3;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 1 ) ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 2 ) ) );
    inputData += 3;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertRGBAToRGB(InputPixelType *inputData,
                   OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size * 4;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 1 ) ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 2 ) ) );
    inputData += 3;
    inputData++; // skip alpha
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertMultiComponentToRGB(InputPixelType *inputData,
                             int inputNumberOfComponents,
                             OutputPixelType *outputData,
                             size_t size)
{
  // assume intensity alpha
  if ( inputNumberOfComponents == 2 )
    {
    InputPixelType *endInput = inputData + size * 2;
    while ( inputData != endInput )
      {
      OutputComponentType val =
        static_cast< OutputComponentType >( *inputData )
        * static_cast< OutputComponentType >( *( inputData + 1 ) );
      inputData += 2;
      OutputConvertTraits::SetNthComponent(0, *outputData, val);
      OutputConvertTraits::SetNthComponent(1, *outputData, val);
      OutputConvertTraits::SetNthComponent(2, *outputData, val);
      outputData++;
      }
    }
  // just skip the rest of the data
  else
    {
    ptrdiff_t       diff = inputNumberOfComponents - 3;
    InputPixelType *endInput = inputData + size * (size_t)inputNumberOfComponents;
    while ( inputData != endInput )
      {
      OutputConvertTraits::SetNthComponent( 0, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *inputData ) );
      OutputConvertTraits::SetNthComponent( 1, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *( inputData + 1 ) ) );
      OutputConvertTraits::SetNthComponent( 2, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *( inputData + 2 ) ) );
      inputData += 3;
      inputData += diff;
      outputData++;
      }
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertGrayToRGBA(InputPixelType *inputData,
                    OutputPixelType *outputData, size_t size)

{
  InputPixelType *endInput = inputData + size;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 3, *outputData,
      static_cast< OutputComponentType >(DefaultAlphaValue<InputPixelType>()));
    inputData++;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertRGBToRGBA(InputPixelType *inputData,
                   OutputPixelType *outputData, size_t size)
{
  using InputConvertTraits = itk::DefaultConvertPixelTraits< InputPixelType >;
  using InputComponentType = typename InputConvertTraits::ComponentType;
  InputPixelType *endInput = inputData + size * 3;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 1 ) ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 2 ) ) );
    OutputConvertTraits::SetNthComponent( 3, *outputData,
  static_cast< OutputComponentType >(DefaultAlphaValue<InputComponentType>()));

    inputData += 3;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertRGBAToRGBA(InputPixelType *inputData,
                    OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size * 4;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 1 ) ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 2 ) ) );
    OutputConvertTraits::SetNthComponent( 3, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 3 ) ) );
    inputData += 4;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertMultiComponentToRGBA(InputPixelType *inputData,
                              int inputNumberOfComponents,
                              OutputPixelType *outputData,
                              size_t size)
{
  // equal weights for 2 components??
  if ( inputNumberOfComponents == 2 )
    {
    InputPixelType *endInput = inputData + size * 2;
    while ( inputData != endInput )
      {
      auto val = static_cast< OutputComponentType >( *inputData );
      auto alpha = static_cast< OutputComponentType >( *( inputData + 1 ) );
      inputData += 2;
      OutputConvertTraits::SetNthComponent(0, *outputData, val);
      OutputConvertTraits::SetNthComponent(1, *outputData, val);
      OutputConvertTraits::SetNthComponent(2, *outputData, val);
      OutputConvertTraits::SetNthComponent(3, *outputData, alpha);
      }
    }
  else
    {
    ptrdiff_t       diff = inputNumberOfComponents - 4;
    InputPixelType *endInput = inputData + size * (size_t)inputNumberOfComponents;
    while ( inputData != endInput )
      {
      OutputConvertTraits::SetNthComponent( 0, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *inputData ) );
      OutputConvertTraits::SetNthComponent( 1, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *( inputData + 1 ) ) );
      OutputConvertTraits::SetNthComponent( 2, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *( inputData + 2 ) ) );
      OutputConvertTraits::SetNthComponent( 3, *outputData,
                                            static_cast< OutputComponentType >
                                            ( *( inputData + 3 ) ) );
      inputData += 4;
      inputData += diff;
      outputData++;
      }
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertTensor6ToTensor6(InputPixelType *inputData,
                          OutputPixelType *outputData, size_t size)
{
  for ( size_t i = 0; i < size; i++ )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >( *( inputData + 1 ) ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast< OutputComponentType >( *( inputData + 2 ) ) );
    OutputConvertTraits::SetNthComponent( 3, *outputData,
                                          static_cast< OutputComponentType >( *( inputData + 3 ) ) );
    OutputConvertTraits::SetNthComponent( 4, *outputData,
                                          static_cast< OutputComponentType >( *( inputData + 4 ) ) );
    OutputConvertTraits::SetNthComponent( 5, *outputData,
                                          static_cast< OutputComponentType >( *( inputData + 5 ) ) );
    ++outputData;
    inputData += 6;
    }
}

// Convert Grayscale to Complex

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertGrayToComplex(InputPixelType *inputData,
                       OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    inputData++;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertComplexToComplex(InputPixelType *inputData,
                          OutputPixelType *outputData, size_t size)
{
  InputPixelType *endInput = inputData + size * 2;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent(
      0, *outputData,
      static_cast< OutputComponentType >
      ( *inputData ) );
    OutputConvertTraits::SetNthComponent(
      1, *outputData,
      static_cast< OutputComponentType >
      ( *( inputData + 1 ) ) );
    inputData += 2;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertTensor9ToTensor6(InputPixelType *inputData,
                          OutputPixelType *outputData, size_t size)
{
  for ( size_t i = 0; i < size; i++ )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast<  OutputComponentType >( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast<  OutputComponentType >( *( inputData + 1 ) ) );
    OutputConvertTraits::SetNthComponent( 2, *outputData,
                                          static_cast<  OutputComponentType >( *( inputData + 2 ) ) );
    OutputConvertTraits::SetNthComponent( 3, *outputData,
                                          static_cast<  OutputComponentType >( *( inputData + 4 ) ) );
    OutputConvertTraits::SetNthComponent( 4, *outputData,
                                          static_cast<  OutputComponentType >( *( inputData + 5 ) ) );
    OutputConvertTraits::SetNthComponent( 5, *outputData,
                                          static_cast<  OutputComponentType >( *( inputData + 8 ) ) );
    ++outputData;
    inputData += 9;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits
          >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertMultiComponentToComplex(InputPixelType *inputData,
                                 int inputNumberOfComponents,
                                 OutputPixelType *outputData,
                                 size_t size)
{
  ptrdiff_t       diff = inputNumberOfComponents - 2;
  InputPixelType *endInput = inputData + size * (size_t)inputNumberOfComponents;

  while ( inputData != endInput )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *inputData ) );
    OutputConvertTraits::SetNthComponent( 1, *outputData,
                                          static_cast< OutputComponentType >
                                          ( *( inputData + 1 ) ) );
    inputData += 2;
    inputData += diff;
    outputData++;
    }
}

template< typename InputPixelType,
          typename OutputPixelType,
          typename OutputConvertTraits >
void
ConvertPixelBuffer< InputPixelType, OutputPixelType, OutputConvertTraits >
::ConvertVectorImage(InputPixelType *inputData,
                     int inputNumberOfComponents,
                     OutputPixelType *outputData, size_t size)
{
  size_t length = size * (size_t)inputNumberOfComponents;

  for ( size_t i = 0; i < length; i++ )
    {
    OutputConvertTraits::SetNthComponent( 0, *outputData,
                                          static_cast<  OutputComponentType >( *inputData ) );
    ++outputData;
    ++inputData;
    }
}
} // end namespace itk

#endif
