ArrayHandleSwizzle.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_cont_ArrayHandleSwizzle_h
#define vtk_m_cont_ArrayHandleSwizzle_h
 
#include <vtkm/cont/ArrayHandleTransform.h>
 
#include <vtkm/VecTraits.h>
 
#include <vtkmstd/integer_sequence.h>
 
namespace vtkm
{
namespace internal
{
 
template <typename InType, typename OutType>
class SwizzleFunctor
{
  using InTraits = vtkm::VecTraits<InType>;
  using InComponentType = typename InTraits::ComponentType;
  static constexpr vtkm::IdComponent NUM_IN_COMPONENTS = InTraits::NUM_COMPONENTS;
 
  using OutTraits = vtkm::VecTraits<OutType>;
  using OutComponentType = typename OutTraits::ComponentType;
  static constexpr vtkm::IdComponent NUM_OUT_COMPONENTS = OutTraits::NUM_COMPONENTS;
 
  template <vtkm::IdComponent... Is>
  using IndexSequence = vtkmstd::integer_sequence<vtkm::IdComponent, Is...>;
  using IndexList = vtkmstd::make_integer_sequence<vtkm::IdComponent, NUM_OUT_COMPONENTS>;
 
public:
  using MapType = vtkm::Vec<vtkm::IdComponent, NUM_OUT_COMPONENTS>;
 
  VTKM_CONT SwizzleFunctor(const MapType& map)
    : Map(map)
  {
  }
 
  VTKM_CONT SwizzleFunctor() = default;
 
  VTKM_EXEC_CONT OutType operator()(const InType& vec) const
  {
    return this->Swizzle(vec, IndexList{});
  }
 
  VTKM_CONT static MapType InitMap() { return IndexListAsMap(IndexList{}); }
 
private:
  template <vtkm::IdComponent... Is>
  VTKM_CONT static MapType IndexListAsMap(IndexSequence<Is...>)
  {
    return { Is... };
  }
 
  template <vtkm::IdComponent... Is>
  VTKM_EXEC_CONT OutType Swizzle(const InType& vec, IndexSequence<Is...>) const
  {
    return { InTraits::GetComponent(vec, this->Map[Is])... };
  }
 
  MapType Map = InitMap();
};
 
namespace detail
{
 
template <typename InType, typename OutType, typename Invertible>
struct GetInverseSwizzleImpl;
 
template <typename InType, typename OutType>
struct GetInverseSwizzleImpl<InType, OutType, std::true_type>
{
  using Type = vtkm::internal::SwizzleFunctor<OutType, InType>;
  template <typename ForwardMapType>
  VTKM_CONT static Type Value(const ForwardMapType& forwardMap)
  {
    // Note that when reversing the map, if the forwardMap repeats any indices, then
    // the map is not 1:1 and is not invertible. We cannot check that at compile time.
    // In this case, results can become unpredictible.
    using InverseMapType = typename Type::MapType;
    InverseMapType inverseMap = Type::InitMap();
    for (vtkm::IdComponent inIndex = 0; inIndex < ForwardMapType::NUM_COMPONENTS; ++inIndex)
    {
      inverseMap[forwardMap[inIndex]] = inIndex;
    }
 
    return Type(inverseMap);
  }
};
 
template <typename InType, typename OutType>
struct GetInverseSwizzleImpl<InType, OutType, std::false_type>
{
  using Type = vtkm::cont::internal::NullFunctorType;
  template <typename ForwardMapType>
  VTKM_CONT static Type Value(const ForwardMapType&)
  {
    return Type{};
  }
};
 
template <typename InType, typename OutType>
using SwizzleInvertible = std::integral_constant<bool,
                                                 vtkm::VecTraits<InType>::NUM_COMPONENTS ==
                                                   vtkm::VecTraits<OutType>::NUM_COMPONENTS>;
 
} // namespace detail
 
template <typename InType, typename OutType>
VTKM_CONT vtkm::internal::SwizzleFunctor<InType, OutType> GetSwizzleFunctor(
  const typename vtkm::internal::SwizzleFunctor<InType, OutType>::MapType& forwardMap)
{
  return vtkm::internal::SwizzleFunctor<InType, OutType>(forwardMap);
}
 
template <typename InType, typename OutType>
using InverseSwizzleType = typename detail::
  GetInverseSwizzleImpl<InType, OutType, detail::SwizzleInvertible<InType, OutType>>::Type;
 
template <typename InType, typename OutType>
VTKM_CONT InverseSwizzleType<InType, OutType> GetInverseSwizzleFunctor(
  const typename vtkm::internal::SwizzleFunctor<InType, OutType>::MapType& forwardMap)
{
  return detail::
    GetInverseSwizzleImpl<InType, OutType, detail::SwizzleInvertible<InType, OutType>>::Value(
      forwardMap);
}
 
}
} // namespace vtkm::internal
 
namespace vtkm
{
namespace cont
{
 
namespace detail
{
 
template <typename ArrayHandleType, vtkm::IdComponent OutSize>
struct ArrayHandleSwizzleTraits
{
  VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
 
  using InType = typename ArrayHandleType::ValueType;
  using OutType = vtkm::Vec<typename vtkm::VecTraits<InType>::ComponentType, OutSize>;
  using SwizzleFunctor = vtkm::internal::SwizzleFunctor<InType, OutType>;
  using InverseSwizzleFunctor = vtkm::internal::InverseSwizzleType<InType, OutType>;
  using MapType = typename SwizzleFunctor::MapType;
 
  static SwizzleFunctor GetFunctor(const MapType& forwardMap)
  {
    return vtkm::internal::GetSwizzleFunctor<InType, OutType>(forwardMap);
  }
 
  static InverseSwizzleFunctor GetInverseFunctor(const MapType& forwardMap)
  {
    return vtkm::internal::GetInverseSwizzleFunctor<InType, OutType>(forwardMap);
  }
 
  using Superclass =
    vtkm::cont::ArrayHandleTransform<ArrayHandleType, SwizzleFunctor, InverseSwizzleFunctor>;
};
 
} // namespace detail
 
template <typename ArrayHandleType, vtkm::IdComponent OutSize>
class ArrayHandleSwizzle
  : public detail::ArrayHandleSwizzleTraits<ArrayHandleType, OutSize>::Superclass
{
  VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
 
  using Traits = detail::ArrayHandleSwizzleTraits<ArrayHandleType, OutSize>;
 
public:
  VTKM_ARRAY_HANDLE_SUBCLASS(ArrayHandleSwizzle,
                             (ArrayHandleSwizzle<ArrayHandleType, OutSize>),
                             (typename Traits::Superclass));
 
  using MapType = typename Traits::MapType;
 
  VTKM_CONT ArrayHandleSwizzle(const ArrayHandleType& array, const MapType& map)
    : Superclass(array, Traits::GetFunctor(map), Traits::GetInverseFunctor(map))
  {
  }
};
 
template <typename ArrayHandleType, vtkm::IdComponent OutSize>
VTKM_CONT ArrayHandleSwizzle<ArrayHandleType, OutSize> make_ArrayHandleSwizzle(
  const ArrayHandleType& array,
  const vtkm::Vec<vtkm::IdComponent, OutSize>& map)
{
  return ArrayHandleSwizzle<ArrayHandleType, OutSize>(array, map);
}
 
template <typename ArrayHandleType, typename... SwizzleIndexTypes>
VTKM_CONT ArrayHandleSwizzle<ArrayHandleType, vtkm::IdComponent(sizeof...(SwizzleIndexTypes) + 1)>
make_ArrayHandleSwizzle(const ArrayHandleType& array,
                        vtkm::IdComponent swizzleIndex0,
                        SwizzleIndexTypes... swizzleIndices)
{
  return make_ArrayHandleSwizzle(array, vtkm::make_Vec(swizzleIndex0, swizzleIndices...));
}
}
} // namespace vtkm::cont
 
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
 
template <typename InType, typename OutType>
struct SerializableTypeString<vtkm::internal::SwizzleFunctor<InType, OutType>>
{
  static VTKM_CONT const std::string& Get()
  {
    static std::string name = "Swizzle<" + SerializableTypeString<InType>::Get() + "," +
      SerializableTypeString<OutType>::Get() + ">";
    return name;
  }
};
 
template <typename AH, vtkm::IdComponent NComps>
struct SerializableTypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
  : SerializableTypeString<typename vtkm::cont::ArrayHandleSwizzle<AH, NComps>::Superclass>
{
};
}
} // vtkm::cont
 
namespace mangled_diy_namespace
{
 
template <typename AH, vtkm::IdComponent NComps>
struct Serialization<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
  : Serialization<typename vtkm::cont::ArrayHandleSwizzle<AH, NComps>::Superclass>
{
};
 
} // diy
 
#endif // vtk_m_cont_ArrayHandleSwizzle_h