otbImage.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * 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
 *
 * 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 otbImage_h
#define otbImage_h
 
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include "itkImage.h"
#pragma GCC diagnostic pop
#else
#include "itkImage.h"
#endif
 
#include "otbImageCommons.h"
#include "OTBImageBaseExport.h"
 
namespace otb
{
namespace internal
{
template <class ImageType>
typename ImageType::SpacingType GetSignedSpacing(const ImageType* input)
{
  typename ImageType::SpacingType   spacing   = input->GetSpacing();
  typename ImageType::DirectionType direction = input->GetDirection();
  for (unsigned int i = 0; i < ImageType::ImageDimension; i++)
  {
    spacing[i] *= direction[i][i];
  }
  return spacing;
}
 
template <class InputImage, typename SpacingType>
void SetSignedSpacing(InputImage* input, SpacingType spacing)
{
  // TODO check for spacing size ==> error
  typename InputImage::DirectionType direction = input->GetDirection();
  for (unsigned int i = 0; i < InputImage::ImageDimension; i++)
  {
    // TODO check if spacing[i] = 0 ==> error
    if (spacing[i] < 0)
    {
      if (direction[i][i] > 0)
      {
        for (unsigned int j = 0; j < InputImage::ImageDimension; j++)
        {
          direction[j][i] = -direction[j][i];
        }
      }
      spacing[i] = -spacing[i];
    }
  }
  input->SetDirection(direction);
  input->SetSpacing(spacing);
}
}
}
 
 
namespace otb
{
template <class TPixel, unsigned int VImageDimension = 2>
class OTBImageBase_EXPORT_TEMPLATE Image
  : public itk::Image<TPixel, VImageDimension>
  , public ImageCommons
{
public:
  using Self = Image;
  using Superclass = itk::Image<TPixel, VImageDimension>;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;
  using ConstWeakPointer = itk::WeakPointer<const Self>;
 
  using VectorType = ImageMetadataInterfaceBase::VectorType;
 
  itkNewMacro(Self);
 
  itkTypeMacro(Image, itk::Image);
 
  typedef typename Superclass::PixelType PixelType;
 
  typedef typename Superclass::ValueType ValueType;
 
  typedef typename Superclass::InternalPixelType InternalPixelType;
 
  typedef typename Superclass::IOPixelType IOPixelType;
 
  // typedef itk::DefaultPixelAccessor< PixelType > AccessorType;
  // typedef itk::DefaultPixelAccessorFunctor< Self > AccessorFunctorType;
 
  typedef itk::NeighborhoodAccessorFunctor<Self> NeighborhoodAccessorFunctorType;
 
  itkStaticConstMacro(ImageDimension, unsigned int, VImageDimension);
 
  typedef typename Superclass::PixelContainer PixelContainer;
 
  typedef typename Superclass::IndexType IndexType;
 
  typedef typename Superclass::OffsetType OffsetType;
 
  typedef typename Superclass::SizeType SizeType;
 
  typedef typename Superclass::DirectionType DirectionType;
 
  typedef typename Superclass::RegionType RegionType;
 
  typedef typename Superclass::SpacingType SpacingType;
 
  typedef typename Superclass::PointType PointType;
 
  typedef typename PixelContainer::Pointer      PixelContainerPointer;
  typedef typename PixelContainer::ConstPointer PixelContainerConstPointer;
 
  typedef typename Superclass::OffsetValueType OffsetValueType;
 
  //   AccessorType GetPixelAccessor( void )
  //   {
  //     return AccessorType();
  //   }
 
  //   const AccessorType GetPixelAccessor( void ) const
  //   {
  //     return AccessorType();
  //   }
 
  NeighborhoodAccessorFunctorType GetNeighborhoodAccessor()
  {
    return NeighborhoodAccessorFunctorType();
  }
 
  const NeighborhoodAccessorFunctorType GetNeighborhoodAccessor() const
  {
    return NeighborhoodAccessorFunctorType();
  }
 
 
  virtual VectorType GetGeoTransform(void) const;
 
  // TODO: GenericRSTransform should be instantiated to translate from physical
  // space to EPSG:4328 ?
  VectorType GetUpperLeftCorner(void) const;
  VectorType GetUpperRightCorner(void) const;
  VectorType GetLowerLeftCorner(void) const;
  VectorType GetLowerRightCorner(void) const;
 
  SpacingType GetSignedSpacing() const;
 
  // SpacingType GetSpacing() const
  //   {
  //     PixelType a;
  //     a.toto();
  //     SpacingType t = this->GetSignedSpacing();
  //     return t ;
  //   };
 
  virtual void SetSignedSpacing(SpacingType spacing);
  virtual void SetSignedSpacing(double spacing[VImageDimension]);
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  void CopyInformation(const itk::DataObject*) override;
 
protected:
  Image();
  ~Image() override
  {
  }
 
private:
  Image(const Self&) = delete;
  void operator=(const Self&) = delete;
};
 
} // end namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbImage.hxx"
#endif
 
#include <complex>
 
namespace otb
{
 
// Prevent implicit instantiation of common types to improve build performance
// Explicit instantiations are provided in the .cxx
extern template class OTBImageBase_EXPORT_TEMPLATE Image<unsigned int, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<int, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<unsigned char, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<char, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<unsigned short, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<short, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<float, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<double, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<std::complex<int>, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<std::complex<short>, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<std::complex<float>, 2>;
extern template class OTBImageBase_EXPORT_TEMPLATE Image<std::complex<double>, 2>;
}
 
#endif