Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 21:33:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Support DynamicArrayHandle::CastToArrayHandle for fancy ArrayHandles

Browse Source 
Basically, this entails adding a constructor to each fancy ArrayHandle
that accepts the base ArrayHandle with the appropriate type and storage.
This commit is contained in:
Kenneth Moreland 2015-09-20 00:28:11 -06:00
parent 0ea9ceb1f8
commit 882c20a2cb
11 changed files with 143 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
vtkm/cont/ArrayHandleCast.h
View File

@ -61,12 +61,21 @@ public:
ArrayHandleType,
internal::Cast<typename ArrayHandleType::ValueType, ValueType> > SuperClass;
typedef typename SuperClass::StorageTag StorageTag;
VTKM_CONT_EXPORT
ArrayHandleCast() : SuperClass()
{ }
VTKM_CONT_EXPORT
ArrayHandleCast(const ArrayHandleType &handle)
: SuperClass(handle)
{ }
VTKM_CONT_EXPORT
ArrayHandleCast(const vtkm::cont::ArrayHandle<ValueType, StorageTag> &src)
: SuperClass(src)
{ }
};
/// make_ArrayHandleCast is convenience function to generate an

13
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -251,12 +251,14 @@ public:
VTKM_CONT_EXPORT
ValueType Get(vtkm::Id vtkmNotUsed(index)) const {
throw vtkm::cont::ErrorControlInternal("Not implemented.");
throw vtkm::cont::ErrorControlInternal(
"Const Array Portal not implemented for composite vector.");
}
VTKM_CONT_EXPORT
void Set(vtkm::Id vtkmNotUsed(index), ValueType vtkmNotUsed(value)) {
throw vtkm::cont::ErrorControlInternal("Not implemented.");
throw vtkm::cont::ErrorControlInternal(
"Const Array Portal not implemented for composite vector.");
}
private:
@ -495,6 +497,7 @@ public:
typename internal::ArrayHandleCompositeVectorTraits<Signature>::Tag>
Superclass;
typedef typename Superclass::ValueType ValueType;
typedef typename Superclass::StorageTag StorageTag;
VTKM_CONT_EXPORT
ArrayHandleCompositeVector() : Superclass() { }
@ -506,6 +509,12 @@ public:
: Superclass(StorageType(arrays, sourceComponents))
{ }
VTKM_CONT_EXPORT
ArrayHandleCompositeVector(
const vtkm::cont::ArrayHandle<ValueType, StorageTag> &src)
: Superclass(src)
{ }
/// Template constructors for passing in types. You'll get weird compile
/// errors if the argument types do not actually match the types in the
/// signature.

7
vtkm/cont/ArrayHandleConstant.h
View File

@ -63,9 +63,16 @@ class ArrayHandleConstant
Superclass;
public:
typedef typename Superclass::StorageTag StorageTag;
VTKM_CONT_EXPORT
ArrayHandleConstant(T value = T(), vtkm::Id numberOfValues = 0)
: Superclass(detail::ConstantFunctor<T>(value), numberOfValues) { }
VTKM_CONT_EXPORT
ArrayHandleConstant(const vtkm::cont::ArrayHandle<T,StorageTag> &src)
: Superclass(src)
{ }
};
/// make_ArrayHandleImplicit is convenience function to generate an

6
vtkm/cont/ArrayHandleCounting.h
View File

@ -114,6 +114,8 @@ class ArrayHandleCounting
typename internal::ArrayHandleCountingTraits<CountingValueType>::Tag
> Superclass;
public:
typedef typename Superclass::ValueType ValueType;
typedef typename Superclass::StorageTag StorageTag;
VTKM_CONT_EXPORT
ArrayHandleCounting(CountingValueType start,
@ -125,6 +127,10 @@ public:
VTKM_CONT_EXPORT
ArrayHandleCounting():Superclass() {}
VTKM_CONT_EXPORT
ArrayHandleCounting(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Superclass(src) { }
};
/// A convenience function for creating an ArrayHandleCounting. It takes the

10
vtkm/cont/ArrayHandleImplicit.h
View File

@ -105,13 +105,19 @@ private:
typedef vtkm::cont::ArrayHandle<ValueType,StorageTag> Superclass;
VTKM_CONT_EXPORT
ArrayHandleImplicit()
: Superclass(typename Superclass::PortalConstControl(FunctorType(),0)) { }
VTKM_CONT_EXPORT
ArrayHandleImplicit(FunctorType functor, vtkm::Id length)
: Superclass(typename Superclass::PortalConstControl(functor,length))
{
}
{ }
VTKM_CONT_EXPORT
ArrayHandleImplicit(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Superclass(src)
{ }
};
/// make_ArrayHandleImplicit is convenience function to generate an

6
vtkm/cont/ArrayHandleIndex.h
View File

@ -49,8 +49,14 @@ class ArrayHandleIndex
Superclass;
public:
typedef Superclass::ValueType ValueType;
typedef Superclass::StorageTag StorageTag;
ArrayHandleIndex(vtkm::Id length = 0)
: Superclass(detail::IndexFunctor(), length) { }
ArrayHandleIndex(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Superclass(src) { }
};
}

4
vtkm/cont/ArrayHandlePermutation.h
View File

@ -385,6 +385,10 @@ public:
ArrayHandlePermutation(const IndexArrayHandleType &indexArray,
const ValueArrayHandleType &valueArray)
: Superclass(StorageType(indexArray, valueArray)) { }
ArrayHandlePermutation(
const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Superclass(src) { }
};
/// make_ArrayHandleTransform is convenience function to generate an

11
vtkm/cont/ArrayHandleTransform.h
View File

@ -137,7 +137,7 @@ private:
};
template<typename ValueType, typename ArrayHandleType, typename FunctorType>
struct StorageTagTransform;
struct StorageTagTransform { };
template<typename T, typename ArrayHandleType, typename FunctorType>
class Storage<T, StorageTagTransform<T, ArrayHandleType, FunctorType > >
@ -310,18 +310,27 @@ class ArrayHandleTransform
// template argument is not a valid ArrayHandle type.
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
public:
typedef internal::StorageTagTransform<ValueType, ArrayHandleType, FunctorType>
StorageTag;
private:
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
public:
typedef vtkm::cont::ArrayHandle<ValueType, StorageTag> Superclass;
VTKM_CONT_EXPORT
ArrayHandleTransform() : Superclass( ) { }
VTKM_CONT_EXPORT
ArrayHandleTransform(const ArrayHandleType &handle,
const FunctorType &functor = FunctorType())
: Superclass(StorageType(handle, functor)) { }
VTKM_CONT_EXPORT
ArrayHandleTransform(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Superclass(src) { }
};
/// make_ArrayHandleTransform is convenience function to generate an

6
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -61,6 +61,12 @@ public:
StorageType(vtkm::internal::ArrayPortalUniformPointCoordinates(
dimensions, origin, spacing)))
{ }
VTKM_CONT_EXPORT
ArrayHandleUniformPointCoordinates(
const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Superclass(src)
{ }
};
}

15
vtkm/cont/ArrayHandleZip.h
View File

@ -155,7 +155,7 @@ private:
};
template<typename FirstHandleType, typename SecondHandleType>
struct StorageTagZip;
struct StorageTagZip { };
/// This helper struct defines the value type for a zip container containing
/// the given two array handles.
@ -361,21 +361,26 @@ class ArrayHandleZip
// template argument is not a valid ArrayHandle type.
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
public:
typedef typename internal::ArrayHandleZipTraits<FirstHandleType,
SecondHandleType>::ValueType VType;
SecondHandleType>::ValueType ValueType;
typedef typename internal::ArrayHandleZipTraits<FirstHandleType,
SecondHandleType>::Tag StorageTag;
typedef vtkm::cont::internal::Storage<VType, StorageTag> StorageType;
typedef vtkm::cont::ArrayHandle<ValueType, StorageTag> Superclass;
private:
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
public:
typedef vtkm::cont::ArrayHandle<VType, StorageTag> Superclass;
ArrayHandleZip() : Superclass( ) { }
ArrayHandleZip(const FirstHandleType &firstArray,
const SecondHandleType &secondArray)
: Superclass( StorageType( firstArray, secondArray ) ) { }
ArrayHandleZip(const vtkm::cont::ArrayHandle<ValueType, StorageTag> &src)
: Superclass(src) { }
};
/// A convenience function for creating an ArrayHandleZip. It takes the two

82
vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx
View File

@ -23,7 +23,16 @@
#include <vtkm/TypeTraits.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/ArrayHandleCast.h>
#include <vtkm/cont/ArrayHandleCompositeVector.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/ArrayHandleImplicit.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ArrayHandleZip.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
@ -86,6 +95,15 @@ struct StorageListTagUnusual :
ArrayHandleWithUnusualStorage<std::string>::StorageTag>
{ };
template<typename T>
struct TestValueFunctor
{
T operator()(vtkm::Id index) const
{
return TestValue(index, T());
}
};
bool CheckCalled;
struct CheckFunctor
@ -162,22 +180,12 @@ void CheckCastToArrayHandle(const ArrayHandleType &array)
ArrayHandleType castArray1;
dynamicArray.CastToArrayHandle(castArray1);
for (vtkm::Id index = 0; index < array.GetNumberOfValues(); index++)
{
VTKM_TEST_ASSERT(test_equal(array.GetPortalConstControl().Get(index),
castArray1.GetPortalConstControl().Get(index)),
"Cast array has bad value.");
}
VTKM_TEST_ASSERT(array == castArray1, "Did not get back same array.");
ArrayHandleType castArray2 =
dynamicArray.CastToArrayHandle(typename ArrayHandleType::ValueType(),
typename ArrayHandleType::StorageTag());
for (vtkm::Id index = 0; index < array.GetNumberOfValues(); index++)
{
VTKM_TEST_ASSERT(test_equal(array.GetPortalConstControl().Get(index),
castArray2.GetPortalConstControl().Get(index)),
"Cast array has bad value.");
}
VTKM_TEST_ASSERT(array == castArray2, "Did not get back same array.");
}
template<typename T, typename DynamicArrayType>
@ -336,12 +344,54 @@ void TryUnusualTypeAndStorage()
void TryCastToArrayHandle()
{
std::cout << " Normal array handle." << std::endl;
vtkm::FloatDefault buffer[ARRAY_SIZE];
vtkm::Id buffer[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
buffer[index] = TestValue(index, vtkm::FloatDefault());
buffer[index] = TestValue(index, vtkm::Id());
}
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE));
vtkm::cont::ArrayHandle<vtkm::Id> array =
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
CheckCastToArrayHandle(array);
std::cout << " Cast array handle." << std::endl;
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandleCast(array, vtkm::FloatDefault()));
std::cout << " Composite vector array handle." << std::endl;
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandleCompositeVector(array, 0, array, 0));
std::cout << " Constant array handle." << std::endl;
CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleConstant(5, ARRAY_SIZE));
std::cout << " Counting array handle." << std::endl;
vtkm::cont::ArrayHandleCounting<vtkm::Id> countingArray(
ARRAY_SIZE-1, -1, ARRAY_SIZE);
CheckCastToArrayHandle(countingArray);
std::cout << " Implicit array handle." << std::endl;
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandleImplicit<vtkm::FloatDefault>(
TestValueFunctor<vtkm::FloatDefault>(), ARRAY_SIZE));
std::cout << " Index array handle." << std::endl;
CheckCastToArrayHandle(vtkm::cont::ArrayHandleIndex(ARRAY_SIZE));
std::cout << " Permutation array handle." << std::endl;
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandlePermutation(countingArray, array));
std::cout << " Transform array handle." << std::endl;
CheckCastToArrayHandle(
vtkm::cont::make_ArrayHandleTransform<vtkm::FloatDefault>(
countingArray,TestValueFunctor<vtkm::FloatDefault>()));
std::cout << " Uniform point coordinates array handle." << std::endl;
CheckCastToArrayHandle(vtkm::cont::ArrayHandleUniformPointCoordinates(
vtkm::Id3(ARRAY_SIZE)));
std::cout << " Zip array handle." << std::endl;
// CheckCastToArrayHandle(vtkm::cont::make_ArrayHandleZip(countingArray, array));
}
void TestDynamicArrayHandle()