text: /*=========================================================================
   *
   *  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 itkGenerateImageSource_hxx
  #define itkGenerateImageSource_hxx
  
  #include "itkGenerateImageSource.h"
  
  namespace itk
  {
  template <typename TOutputImage>
  GenerateImageSource<TOutputImage>::GenerateImageSource()
    : m_Spacing(1.0)
    , m_Origin(0.0)
  
  {
    this->m_Size.Fill(64); // arbitrary default size
    this->m_Direction.SetIdentity();
    this->m_StartIndex.Fill(0);
  
    // Pipeline input configuration
  
    // implicit: No Input Required
    // "ReferenceImage" optional
    Self::AddOptionalInputName("ReferenceImage", 1);
  }
  
  template <typename TOutputImage>
  void
  GenerateImageSource<TOutputImage>::GenerateOutputInformation()
  {
    // No need to call Superclass::GenerateOutputInformation. No input.
    for (unsigned int n = 0; n < this->GetNumberOfOutputs(); ++n)
    {
      OutputImageType * outputPtr = this->GetOutput(n);
  
      if (!outputPtr)
      {
        continue;
      }
  
      const ReferenceImageBaseType * referenceImage = this->GetReferenceImage();
  
      // Set size, spacing, origin
      if (m_UseReferenceImage && referenceImage)
      {
        outputPtr->SetLargestPossibleRegion(referenceImage->GetLargestPossibleRegion());
  
        outputPtr->SetSpacing(referenceImage->GetSpacing());
        outputPtr->SetOrigin(referenceImage->GetOrigin());
        outputPtr->SetDirection(referenceImage->GetDirection());
      }
      else
      {
        typename TOutputImage::RegionType outputLargestPossibleRegion;
        outputLargestPossibleRegion.SetSize(m_Size);
        outputLargestPossibleRegion.SetIndex(m_StartIndex);
        outputPtr->SetLargestPossibleRegion(outputLargestPossibleRegion);
  
        outputPtr->SetSpacing(m_Spacing);
        outputPtr->SetOrigin(m_Origin);
        outputPtr->SetDirection(m_Direction);
      }
    }
  }
  
  template <typename TOutputImage>
  void
  GenerateImageSource<TOutputImage>::SetOutputParametersFromImage(const ReferenceImageBaseType * image)
  {
    this->SetOrigin(image->GetOrigin());
    this->SetSpacing(image->GetSpacing());
    this->SetDirection(image->GetDirection());
    this->SetStartIndex(image->GetLargestPossibleRegion().GetIndex());
    this->SetSize(image->GetLargestPossibleRegion().GetSize());
  }
  
  template <typename TOutputImage>
  void
  GenerateImageSource<TOutputImage>::PrintSelf(std::ostream & os, Indent indent) const
  {
    Superclass::PrintSelf(os, indent);
  
    os << indent << "Size: " << static_cast<typename NumericTraits<SizeType>::PrintType>(m_Size) << std::endl;
    os << indent << "Spacing: " << static_cast<typename NumericTraits<SpacingType>::PrintType>(m_Spacing) << std::endl;
    os << indent << "Origin: " << static_cast<typename NumericTraits<PointType>::PrintType>(m_Origin) << std::endl;
    os << indent << "Direction: " << static_cast<typename NumericTraits<DirectionType>::PrintType>(m_Direction)
       << std::endl;
    os << indent << "UseReferenceImage: " << this->GetUseReferenceImage() << std::endl;
  }
  } // end namespace itk
  
  #endif // itkGenerateImageSour_hxx
  