/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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 itkChangeInformationImageFilter_hxx
#define itkChangeInformationImageFilter_hxx

#include "itkChangeInformationImageFilter.h"
#include "itkImageRegionIterator.h"
#include "itkContinuousIndex.h"
#include "itkObjectFactory.h"

namespace itk
{
/**
 *
 */
template <typename TInputImage>
ChangeInformationImageFilter<TInputImage>::ChangeInformationImageFilter()
{
  m_ReferenceImage = nullptr;

  m_ChangeSpacing = false;
  m_ChangeOrigin = false;
  m_ChangeDirection = false;
  m_ChangeRegion = false;

  m_CenterImage = false;
  m_UseReferenceImage = false;

  m_OutputSpacing.Fill(1.0);
  m_OutputOrigin.Fill(0.0);
  m_OutputDirection.SetIdentity();
  m_OutputOffset.Fill(0);
}

template <typename TInputImage>
void
ChangeInformationImageFilter<TInputImage>::GenerateOutputInformation()
{
  Superclass::GenerateOutputInformation();

  unsigned int i;

  typename TInputImage::RegionType outputRegion;
  typename TInputImage::SizeType   inputSize;
  typename TInputImage::SizeType   outputSize;
  typename TInputImage::IndexType  outputIndex;
  typename TInputImage::IndexType  inputIndex;
  PointType                        origin;
  SpacingType                      spacing;
  DirectionType                    direction;

  itkDebugMacro("GenerateOutputInformation Start");

  // Get pointers to the input and output
  typename Superclass::OutputImagePointer output = this->GetOutput();
  typename Superclass::InputImagePointer  input = const_cast<TInputImage *>(this->GetInput());

  if (!output || !input)
  {
    return;
  }

  inputIndex = input->GetLargestPossibleRegion().GetIndex();

  // Default is to copy input's information
  output->CopyInformation(input);

  // Output size is always the same as input size
  inputSize = input->GetLargestPossibleRegion().GetSize();
  outputSize = inputSize;

  // Establish the source of the image information
  if (m_UseReferenceImage && m_ReferenceImage)
  {
    outputIndex = m_ReferenceImage->GetLargestPossibleRegion().GetIndex();
    origin = m_ReferenceImage->GetOrigin();
    spacing = m_ReferenceImage->GetSpacing();
    direction = m_ReferenceImage->GetDirection();
    m_Shift = outputIndex - inputIndex;

    // reset outputIndex to the input index since we add m_Shift to
    // outputIndex latter on
    outputIndex = input->GetLargestPossibleRegion().GetIndex();
  }
  else
  {
    outputIndex = input->GetLargestPossibleRegion().GetIndex();
    origin = m_OutputOrigin;
    spacing = m_OutputSpacing;
    direction = m_OutputDirection;
    m_Shift = m_OutputOffset;
  }

  // Change the output spacing
  if (m_ChangeSpacing)
  {
    output->SetSpacing(spacing);
  }

  // Change the output origin
  if (m_ChangeOrigin)
  {
    output->SetOrigin(origin);
  }

  // Change the output direction
  if (m_ChangeDirection)
  {
    output->SetDirection(direction);
  }

  // Center the image by changing its origin
  // The center of the image is computed using the index to point
  // transformation. This ensures that the computation will work for
  // both images and oriented images.
  if (m_CenterImage)
  {
    typename TInputImage::PointType                     centerPoint;
    ContinuousIndex<SpacePrecisionType, ImageDimension> centerIndex;

    for (i = 0; i < ImageDimension; i++)
    {
      centerIndex[i] = static_cast<double>((outputSize[i] - 1) / 2.0);
    }
    output->TransformContinuousIndexToPhysicalPoint(centerIndex, centerPoint);
    for (i = 0; i < ImageDimension; i++)
    {
      origin[i] = output->GetOrigin()[i] - centerPoint[i];
    }
    output->SetOrigin(origin);
  }

  // Change the output's largest possible region
  if (m_ChangeRegion)
  {
    outputRegion.SetSize(outputSize);
    outputRegion.SetIndex(outputIndex + m_Shift);
    output->SetLargestPossibleRegion(outputRegion);
  }
  else
  {
    m_Shift.Fill(0);
  }
  itkDebugMacro("GenerateOutputInformation End");
}

template <typename TInputImage>
void
ChangeInformationImageFilter<TInputImage>::GenerateInputRequestedRegion()
{
  Superclass::GenerateInputRequestedRegion();

  if (this->GetInput())
  {
    typename TInputImage::RegionType region;
    region.SetSize(this->GetOutput()->GetRequestedRegion().GetSize());
    region.SetIndex(this->GetOutput()->GetRequestedRegion().GetIndex() - m_Shift);
    auto * input = const_cast<InputImageType *>(this->GetInput());
    input->SetRequestedRegion(region);
  }
}

template <typename TInputImage>
void
ChangeInformationImageFilter<TInputImage>::GenerateData()
{
  // Get pointers to the input and output
  OutputImageType *      output = this->GetOutput();
  const InputImageType * input = this->GetInput();

  auto * nonConstInput = const_cast<InputImageType *>(input);

  // No need to copy the bulk data
  output->SetPixelContainer(nonConstInput->GetPixelContainer());

  // Shift the output's buffer region
  typename TInputImage::RegionType region;
  region.SetSize(input->GetBufferedRegion().GetSize());
  region.SetIndex(input->GetBufferedRegion().GetIndex() + m_Shift);

  output->SetBufferedRegion(region);
}

/**
 *
 */
template <typename TInputImage>
void
ChangeInformationImageFilter<TInputImage>::PrintSelf(std::ostream & os, Indent indent) const
{
  Superclass::PrintSelf(os, indent);

  os << indent << "CenterImage: " << (m_CenterImage ? "On" : "Off") << std::endl;
  os << indent << "ChangeSpacing: " << (m_ChangeSpacing ? "On" : "Off") << std::endl;
  os << indent << "ChangeOrigin: " << (m_ChangeOrigin ? "On" : "Off") << std::endl;
  os << indent << "ChangeDirection: " << (m_ChangeDirection ? "On" : "Off") << std::endl;
  os << indent << "ChangeRegion: " << (m_ChangeRegion ? "On" : "Off") << std::endl;
  os << indent << "UseReferenceImage: " << (m_UseReferenceImage ? "On" : "Off") << std::endl;
  if (m_ReferenceImage)
  {
    os << indent << "ReferenceImage: " << m_ReferenceImage.GetPointer() << std::endl;
  }
  else
  {
    os << indent << "ReferenceImage: 0" << std::endl;
  }
  os << indent << "OutputSpacing: [";
  if (ImageDimension >= 1)
  {
    os << m_OutputSpacing[0];
  }
  for (unsigned int j = 1; j < ImageDimension; j++)
  {
    os << ", " << m_OutputSpacing[j];
  }
  os << "]" << std::endl;

  os << indent << "OutputOrigin: [";
  if (ImageDimension >= 1)
  {
    os << m_OutputOrigin[0];
  }
  for (unsigned int j = 1; j < ImageDimension; j++)
  {
    os << ", " << m_OutputOrigin[j];
  }
  os << "]" << std::endl;

  os << indent << "OutputDirection:" << std::endl;
  os << m_OutputDirection << std::endl;

  os << indent << "OutputOffset: [";
  os << m_OutputOffset << std::endl;
}
} // end namespace itk

#endif
