ArrayExtractComponent.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_ArrayExtractComponent_h
#define vtk_m_cont_ArrayExtractComponent_h
 
#include <vtkm/cont/ArrayHandleBasic.h>
#include <vtkm/cont/ArrayHandleStride.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Logging.h>
 
#include <vtkm/TypeTraits.h>
#include <vtkm/VecFlat.h>
#include <vtkm/VecTraits.h>
 
#include <vtkmstd/integer_sequence.h>
 
#include <vtkm/cont/vtkm_cont_export.h>
 
namespace vtkm
{
namespace cont
{
 
namespace internal
{
 
// Note: Using partial template specialization instead of function overloading to
// specialize ArrayExtractComponent for different types of array handles. This is
// because function overloading from a templated function is done when the template
// is defined rather than where it is resolved. This causes problems when extracting
// components of, say, an ArrayHandleMultiplexer holding an ArrayHandleSOA.
template <typename T, typename S>
vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType>
ArrayExtractComponentFallback(const vtkm::cont::ArrayHandle<T, S>& src,
                              vtkm::IdComponent componentIndex,
                              vtkm::CopyFlag allowCopy)
{
  if (allowCopy != vtkm::CopyFlag::On)
  {
    throw vtkm::cont::ErrorBadValue("Cannot extract component of " +
                                    vtkm::cont::TypeToString<vtkm::cont::ArrayHandle<T, S>>() +
                                    " without copying");
  }
  VTKM_LOG_S(vtkm::cont::LogLevel::Warn,
             "Extracting component " << componentIndex << " of "
                                     << vtkm::cont::TypeToString<vtkm::cont::ArrayHandle<T, S>>()
                                     << " requires an inefficient memory copy.");
 
  using BaseComponentType = typename vtkm::VecTraits<T>::BaseComponentType;
  vtkm::Id numValues = src.GetNumberOfValues();
  vtkm::cont::ArrayHandleBasic<BaseComponentType> dest;
  dest.Allocate(numValues);
  auto srcPortal = src.ReadPortal();
  auto destPortal = dest.WritePortal();
  for (vtkm::Id arrayIndex = 0; arrayIndex < numValues; ++arrayIndex)
  {
    destPortal.Set(arrayIndex,
                   vtkm::internal::GetFlatVecComponent(srcPortal.Get(arrayIndex), componentIndex));
  }
 
  return vtkm::cont::ArrayHandleStride<BaseComponentType>(dest, numValues, 1, 0);
}
 
// Used as a superclass for ArrayHandleComponentImpls that are inefficient (and should be
// avoided).
struct ArrayExtractComponentImplInefficient
{
};
 
template <typename S>
struct ArrayExtractComponentImpl : ArrayExtractComponentImplInefficient
{
  template <typename T>
  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> operator()(
    const vtkm::cont::ArrayHandle<T, S>& src,
    vtkm::IdComponent componentIndex,
    vtkm::CopyFlag allowCopy) const
  {
    // This is the slow "default" implementation. ArrayHandle implementations should provide
    // more efficient overloads where applicable.
    return vtkm::cont::internal::ArrayExtractComponentFallback(src, componentIndex, allowCopy);
  }
};
 
template <>
struct ArrayExtractComponentImpl<vtkm::cont::StorageTagStride>
{
  template <typename T>
  vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> operator()(
    const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagStride>& src,
    vtkm::IdComponent componentIndex,
    vtkm::CopyFlag allowCopy) const
  {
    return this->DoExtract(
      src, componentIndex, allowCopy, typename vtkm::VecTraits<T>::HasMultipleComponents{});
  }
 
private:
  template <typename T>
  auto DoExtract(const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagStride>& src,
                 vtkm::IdComponent componentIndex,
                 vtkm::CopyFlag vtkmNotUsed(allowCopy),
                 vtkm::VecTraitsTagSingleComponent) const
  {
    VTKM_ASSERT(componentIndex == 0);
    using VTraits = vtkm::VecTraits<T>;
    using TBase = typename VTraits::BaseComponentType;
    VTKM_STATIC_ASSERT(VTraits::NUM_COMPONENTS == 1);
 
    vtkm::cont::ArrayHandleStride<T> array(src);
 
    // Note, we are initializing the result in this strange way for cases where type
    // T has a single component but does not equal its own BaseComponentType. A vtkm::Vec
    // of size 1 fits into this category.
    return vtkm::cont::ArrayHandleStride<TBase>(array.GetBuffers()[1],
                                                array.GetNumberOfValues(),
                                                array.GetStride(),
                                                array.GetOffset(),
                                                array.GetModulo(),
                                                array.GetDivisor());
  }
 
  template <typename VecType>
  auto DoExtract(const vtkm::cont::ArrayHandle<VecType, vtkm::cont::StorageTagStride>& src,
                 vtkm::IdComponent componentIndex,
                 vtkm::CopyFlag allowCopy,
                 vtkm::VecTraitsTagMultipleComponents) const
  {
    using VTraits = vtkm::VecTraits<VecType>;
    using T = typename VTraits::ComponentType;
    constexpr vtkm::IdComponent N = VTraits::NUM_COMPONENTS;
 
    constexpr vtkm::IdComponent subStride = vtkm::internal::TotalNumComponents<T>::value;
    vtkm::cont::ArrayHandleStride<VecType> array(src);
    vtkm::cont::ArrayHandleStride<T> tmpIn(array.GetBuffers()[1],
                                           array.GetNumberOfValues(),
                                           array.GetStride() * N,
                                           (array.GetOffset() * N) + (componentIndex / subStride),
                                           array.GetModulo() * N,
                                           array.GetDivisor());
    return (*this)(tmpIn, componentIndex % subStride, allowCopy);
  }
};
 
template <>
struct ArrayExtractComponentImpl<vtkm::cont::StorageTagBasic>
{
  template <typename T>
  auto operator()(const vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>& src,
                  vtkm::IdComponent componentIndex,
                  vtkm::CopyFlag allowCopy) const
    -> decltype(
      ArrayExtractComponentImpl<vtkm::cont::StorageTagStride>{}(vtkm::cont::ArrayHandleStride<T>{},
                                                                componentIndex,
                                                                allowCopy))
  {
    return ArrayExtractComponentImpl<vtkm::cont::StorageTagStride>{}(
      vtkm::cont::ArrayHandleStride<T>(src, src.GetNumberOfValues(), 1, 0),
      componentIndex,
      allowCopy);
  }
};
 
namespace detail
{
 
template <std::size_t, typename Super>
struct ForwardSuper : Super
{
};
 
template <typename sequence, typename... Supers>
struct SharedSupersImpl;
 
template <std::size_t... Indices, typename... Supers>
struct SharedSupersImpl<vtkmstd::index_sequence<Indices...>, Supers...>
  : ForwardSuper<Indices, Supers>...
{
};
 
} // namespace detail
 
// `ArrayExtractComponentImpl`s that modify the behavior from other storage types might
// want to inherit from the `ArrayExtractComponentImpl`s of these storage types. However,
// if the template specifies multiple storage types, two of the same might be specified,
// and it is illegal in C++ to directly inherit from the same type twice. This special
// superclass accepts a variable amout of superclasses. Inheriting from this will inherit
// from all these superclasses, and duplicates are allowed.
template <typename... Supers>
using DuplicatedSuperclasses =
  detail::SharedSupersImpl<vtkmstd::make_index_sequence<sizeof...(Supers)>, Supers...>;
 
template <typename... StorageTags>
using ArrayExtractComponentImplInherit =
  DuplicatedSuperclasses<vtkm::cont::internal::ArrayExtractComponentImpl<StorageTags>...>;
 
template <typename ArrayHandleType>
using ArrayExtractComponentIsInefficient = typename std::is_base_of<
  vtkm::cont::internal::ArrayExtractComponentImplInefficient,
  vtkm::cont::internal::ArrayExtractComponentImpl<typename ArrayHandleType::StorageTag>>::type;
 
} // namespace internal
 
template <typename T, typename S>
vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> ArrayExtractComponent(
  const vtkm::cont::ArrayHandle<T, S>& src,
  vtkm::IdComponent componentIndex,
  vtkm::CopyFlag allowCopy = vtkm::CopyFlag::On)
{
  return internal::ArrayExtractComponentImpl<S>{}(src, componentIndex, allowCopy);
}
 
}
} // namespace vtkm::cont
 
#endif //vtk_m_cont_ArrayExtractComponent_h