otbArrayTraits.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 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 otbArrayTraits_h
#define otbArrayTraits_h
 
#include "itkDefaultConvertPixelTraits.h"
#include "itkVariableLengthVector.h"
#include "itkFixedArray.h"
 
namespace otb
{
namespace mpl
{
 
/*===============================[ otb::is_array<> ]=========================*/
namespace internals
{
 
template <typename T, unsigned int N>
constexpr std::true_type is_array_f(itk::FixedArray<T, N> const*);
 
template <typename... T>
constexpr std::false_type is_array_f(...);
 
static_assert(decltype(internals::is_array_f(std::declval<itk::FixedArray<int, 1>*>()))::value, "it::FixedArray should be matched");
} // internals namespace
 
template <typename T>
struct is_array
: decltype(internals::is_array_f(std::declval<T*>()))
{};
 
template <typename T>
struct is_array<itk::VariableLengthVector<T>>
: std::true_type
{};
 
template <typename TExpr1, typename TExpr2, typename TBinaryOp>
struct is_array<itk::VariableLengthVectorExpression<TExpr1, TExpr2,TBinaryOp>>
: std::true_type
{};
 
 
template <typename T>
constexpr bool is_array_v = is_array<T>::value;
 
// static_assert(decltype(internals::is_array_f(std::declval<itk::RGBAPixel<int>*>()))::value, "");
 
// static_assert(is_array_v<itk::RGBAPixel<double>>, "");
static_assert(is_array_v<itk::FixedArray<double, 42>>, "");
static_assert(is_array_v<itk::FixedArray<std::complex<double>, 42>>, "");
static_assert(is_array_v<itk::VariableLengthVector<double>>, "");
static_assert(is_array_v<itk::VariableLengthVector<std::complex<double>>>, "");
 
/*===============================[ GetNumberOfComponents ]===================*/
namespace internals
{
 
template <typename PixelType>
struct NumberOfComponents
{
  static unsigned int For(PixelType const& pix)
  {
    return itk::DefaultConvertPixelTraits<std::remove_const_t<PixelType>>::GetNumberOfComponents(pix);
  }
};
 
template <typename RealType>
struct NumberOfComponents<itk::VariableLengthVector<RealType>>
{
  // ITK definition of
  // DefaultConvertPixelTraits<VLV>::GetNumberOfComponents() takes the
  // parameter by value, and thus create a new VLV by copy.
  // This is too expensive! Let's work around it.
  static unsigned int For(itk::VariableLengthVector<RealType> const& pix)
  {
    return pix.GetSize();
  }
};
 
template <typename T>
struct NumberOfComponents<std::complex<T>>
{
  static constexpr unsigned int For(std::complex<T> const&) noexcept
  {
    return 2;
  }
};
 
template <typename T>
struct NumberOfComponents<T const>
{
  static unsigned int For(T const& pix)
  {
    return NumberOfComponents<T>::For(pix);
  }
};
} // internals namespace
 
template <typename PixelType>
inline
unsigned int GetNumberOfComponents(PixelType const& pix)
{
  return internals::NumberOfComponents<PixelType>::For(pix);
}
 
} // otb::mpl namespace
} // otb namespace
 
#endif  // otbArrayTraits_h