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

Merge branch 'master' into add-external-faces

Browse Source
This commit is contained in:
Robert Maynard 2015-08-26 08:23:26 -04:00
commit e583d0f7d8
30 changed files with 845 additions and 1571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -20,94 +20,13 @@
#ifndef vtk_m_cont_ArrayHandleUniformPointCoordinates_h
#define vtk_m_cont_ArrayHandleUniformPointCoordinates_h
#include <vtkm/Extent.h>
#include <vtkm/internal/ArrayPortalUniformPointCoordinates.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/StorageImplicit.h>
namespace vtkm {
namespace cont {
namespace internal {
/// \brief An implicit array port that computes point coordinates for a uniform
/// grid.
///
class ArrayPortalUniformPointCoordinates
{
public:
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates() : NumberOfValues(0) { }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates(vtkm::Extent3 extent,
ValueType origin,
ValueType spacing)
: Extent(extent),
Dimensions(vtkm::ExtentPointDimensions(extent)),
NumberOfValues(vtkm::ExtentNumberOfPoints(extent)),
Origin(origin),
Spacing(spacing)
{ }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates(
const ArrayPortalUniformPointCoordinates &src)
: Extent(src.Extent),
Dimensions(src.Dimensions),
NumberOfValues(src.NumberOfValues),
Origin(src.Origin),
Spacing(src.Spacing)
{ }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates &
operator=(const ArrayPortalUniformPointCoordinates &src)
{
this->Extent = src.Extent;
this->Dimensions = src.Dimensions;
this->NumberOfValues = src.NumberOfValues;
this->Origin = src.Origin;
this->Spacing = src.Spacing;
return *this;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return this->GetCoordinatesForTopologyIndex(
vtkm::ExtentPointFlatIndexToTopologyIndex(index, this->Extent));
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id3 GetRange3() const { return this->Dimensions; }
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id3 index) const {
return this->GetCoordinatesForTopologyIndex(index + this->Extent.Min);
}
private:
vtkm::Extent3 Extent;
vtkm::Id3 Dimensions;
vtkm::Id NumberOfValues;
ValueType Origin;
ValueType Spacing;
VTKM_EXEC_CONT_EXPORT
ValueType GetCoordinatesForTopologyIndex(vtkm::Id3 ijk) const {
return ValueType(this->Origin[0] + this->Spacing[0] * static_cast<vtkm::FloatDefault>(ijk[0]),
this->Origin[1] + this->Spacing[1] * static_cast<vtkm::FloatDefault>(ijk[1]),
this->Origin[2] + this->Spacing[2] * static_cast<vtkm::FloatDefault>(ijk[2]));
}
};
} // namespace internal
/// ArrayHandleUniformPointCoordinates is a specialization of ArrayHandle. It
/// contains the information necessary to compute the point coordinates in a
/// uniform orthogonal grid (extent, origin, and spacing) and implicitly
@ -117,31 +36,30 @@ class ArrayHandleUniformPointCoordinates
: public vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::StorageTagImplicit<
internal::ArrayPortalUniformPointCoordinates> >
vtkm::internal::ArrayPortalUniformPointCoordinates> >
{
public:
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
private:
typedef vtkm::cont::StorageTagImplicit<
internal::ArrayPortalUniformPointCoordinates> StorageTag;
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
vtkm::internal::ArrayPortalUniformPointCoordinates> StorageTag;
typedef vtkm::cont::ArrayHandle<ValueType, StorageTag> Superclass;
private:
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
public:
VTKM_CONT_EXPORT
ArrayHandleUniformPointCoordinates() : Superclass() { }
VTKM_CONT_EXPORT
ArrayHandleUniformPointCoordinates(vtkm::Extent3 extent,
ValueType origin,
ValueType spacing)
ArrayHandleUniformPointCoordinates(
vtkm::Id3 dimensions,
ValueType origin = ValueType(0.0f, 0.0f, 0.0f),
ValueType spacing = ValueType(1.0f, 1.0f, 1.0f))
: Superclass(
StorageType(internal::ArrayPortalUniformPointCoordinates(extent,
origin,
spacing)))
StorageType(vtkm::internal::ArrayPortalUniformPointCoordinates(
dimensions, origin, spacing)))
{ }
};

4
vtkm/cont/CMakeLists.txt
View File

@ -44,7 +44,6 @@ set(headers
DeviceAdapterSerial.h
DynamicArrayHandle.h
DynamicCellSet.h
DynamicPointCoordinates.h
Error.h
ErrorControl.h
ErrorControlAssert.h
@ -55,9 +54,6 @@ set(headers
ErrorExecution.h
Field.h
LogicalStructure.h
PointCoordinatesArray.h
PointCoordinatesListTag.h
PointCoordinatesUniform.h
Storage.h
StorageBasic.h
StorageImplicit.h

172
vtkm/cont/CoordinateSystem.h
View File

@ -20,70 +20,150 @@
#ifndef vtk_m_cont_CoordinateSystem_h
#define vtk_m_cont_CoordinateSystem_h
#include <vtkm/Types.h>
#include <vector>
#include <string>
#include <ostream>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/Field.h>
#ifndef VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG
#define VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG \
::vtkm::TypeListTagFieldVec3
#endif
#ifndef VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG
#define VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG \
::vtkm::cont::StorageListTagCoordinateSystemDefault
#endif
namespace vtkm {
namespace cont {
class CoordinateSystem
/// \brief Default storage list for CoordinateSystem arrays.
///
/// \c VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG is set to this value
/// by default (unless it is defined before including VTK-m headers.
///
struct StorageListTagCoordinateSystemDefault
: vtkm::ListTagJoin<
VTKM_DEFAULT_STORAGE_LIST_TAG,
vtkm::ListTagBase<vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag> >
{ };
typedef vtkm::cont::DynamicArrayHandleBase<
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG,
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG>
DynamicArrayHandleCoordinateSystem;
class CoordinateSystem : public vtkm::cont::Field
{
typedef vtkm::cont::Field Superclass;
public:
struct CoordinateAxis
{
std::string FieldName;
vtkm::IdComponent FieldComponent;
VTKM_CONT_EXPORT
CoordinateAxis(const std::string &name,
vtkm::IdComponent componentIndex = 0)
: FieldName(name), FieldComponent(componentIndex)
{
}
};
VTKM_CONT_EXPORT
CoordinateSystem(std::string name,
vtkm::IdComponent order,
const vtkm::cont::DynamicArrayHandle &data)
: Superclass(name, order, ASSOC_POINTS, data) { }
template<typename T, typename Storage>
VTKM_CONT_EXPORT
CoordinateSystem(std::string name,
vtkm::IdComponent order,
const ArrayHandle<T, Storage> &data)
: Superclass(name, order, ASSOC_POINTS, data) { }
template<typename T>
VTKM_CONT_EXPORT
CoordinateSystem(std::string name,
vtkm::IdComponent order,
const std::vector<T> &data)
: Superclass(name, order, ASSOC_POINTS, data) { }
template<typename T>
VTKM_CONT_EXPORT
CoordinateSystem(std::string name,
vtkm::IdComponent order,
const T *data,
vtkm::Id numberOfValues)
: Superclass(name, order, ASSOC_POINTS, data, numberOfValues) { }
/// This constructor of coordinate system sets up a regular grid of points.
///
VTKM_CONT_EXPORT
CoordinateSystem(std::string name,
vtkm::IdComponent order,
vtkm::Id3 dimensions,
vtkm::Vec<vtkm::FloatDefault,3> origin
= vtkm::Vec<vtkm::FloatDefault,3>(0.0f, 0.0f, 0.0f),
vtkm::Vec<vtkm::FloatDefault,3> spacing
= vtkm::Vec<vtkm::FloatDefault,3>(1.0f, 1.0f, 1.0f))
: Superclass(name,
order,
ASSOC_POINTS,
vtkm::cont::DynamicArrayHandle(
vtkm::cont::ArrayHandleUniformPointCoordinates(dimensions, origin, spacing)))
{ }
VTKM_CONT_EXPORT
CoordinateSystem(std::string nx,
std::string ny,
std::string nz)
vtkm::cont::DynamicArrayHandleCoordinateSystem GetData() const
{
this->Axes.push_back(CoordinateAxis(nx));
this->Axes.push_back(CoordinateAxis(ny));
this->Axes.push_back(CoordinateAxis(nz));
return vtkm::cont::DynamicArrayHandleCoordinateSystem(
this->Superclass::GetData());
}
VTKM_CONT_EXPORT
CoordinateSystem(std::string nx,
std::string ny)
vtkm::cont::DynamicArrayHandleCoordinateSystem GetData()
{
this->Axes.push_back(CoordinateAxis(nx));
this->Axes.push_back(CoordinateAxis(ny));
return vtkm::cont::DynamicArrayHandleCoordinateSystem(
this->Superclass::GetData());
}
template<typename DeviceAdapterTag, typename TypeList>
VTKM_CONT_EXPORT
const vtkm::cont::ArrayHandle<vtkm::Float64>& GetBounds(DeviceAdapterTag,
TypeList) const
{
return this->Superclass::GetBounds(
DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList>
VTKM_CONT_EXPORT
void GetBounds(vtkm::Float64 *bounds, DeviceAdapterTag, TypeList) const
{
this->Superclass::GetBounds(
bounds, DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag>
VTKM_CONT_EXPORT
const vtkm::cont::ArrayHandle<vtkm::Float64>& GetBounds(DeviceAdapterTag) const
{
return this->Superclass::GetBounds(
DeviceAdapterTag(),
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag>
VTKM_CONT_EXPORT
void GetBounds(vtkm::Float64 *bounds, DeviceAdapterTag) const
{
this->Superclass::GetBounds(
bounds,
DeviceAdapterTag(),
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
VTKM_CONT_EXPORT
CoordinateSystem(std::string nx)
virtual void PrintSummary(std::ostream &out) const
{
this->Axes.push_back(CoordinateAxis(nx));
out << " Coordinate System ";
this->PrintSummary(out);
}
VTKM_CONT_EXPORT
void PrintSummary(std::ostream &out) const
{
out<<" {";
for (std::size_t i = 0; i < this->Axes.size(); i++)
{
out<<this->Axes[i].FieldName<<"["<<this->Axes[i].FieldComponent<<"]";
if (i < this->Axes.size()-1)
{
out<<", ";
}
}
out<<"}\n";
}
private:
std::vector<CoordinateAxis> Axes;
};
} // namespace cont

64
vtkm/cont/DataSet.h
View File

@ -50,16 +50,20 @@ public:
const vtkm::cont::Field &GetField(vtkm::Id index) const
{
VTKM_ASSERT_CONT((index >= 0) &&
(index <= static_cast<vtkm::Id>(this->Fields.size())));
(index < this->GetNumberOfFields()));
return this->Fields[static_cast<std::size_t>(index)];
}
VTKM_CONT_EXPORT
const vtkm::cont::Field &GetField(const std::string &name) const
const vtkm::cont::Field &GetField(const std::string &name,
vtkm::cont::Field::AssociationEnum assoc = vtkm::cont::Field::ASSOC_ANY)
const
{
for (std::size_t i=0; i < this->Fields.size(); ++i)
{
if (this->Fields[i].GetName() == name)
if ((assoc == vtkm::cont::Field::ASSOC_ANY ||
assoc == this->Fields[i].GetAssociation()) &&
this->Fields[i].GetName() == name)
{
return this->Fields[i];
}
@ -67,20 +71,36 @@ public:
throw vtkm::cont::ErrorControlBadValue("No field with requested name");
}
VTKM_CONT_EXPORT
vtkm::cont::DynamicCellSet GetCellSet(vtkm::Id index=0) const
{
VTKM_ASSERT_CONT((index >= 0) &&
(index <= static_cast<vtkm::Id>(this->CellSets.size())));
return this->CellSets[static_cast<std::size_t>(index)];
}
VTKM_CONT_EXPORT
void AddCoordinateSystem(vtkm::cont::CoordinateSystem cs)
{
this->CoordSystems.push_back(cs);
}
VTKM_CONT_EXPORT
const vtkm::cont::CoordinateSystem &
GetCoordinateSystem(vtkm::Id index=0) const
{
VTKM_ASSERT_CONT((index >= 0) &&
(index < this->GetNumberOfCoordinateSystems()));
return this->CoordSystems[static_cast<std::size_t>(index)];
}
VTKM_CONT_EXPORT
const vtkm::cont::CoordinateSystem &
GetCoordinateSystem(const std::string &name) const
{
for (std::size_t i=0; i < this->CoordSystems.size(); ++i)
{
if (this->CoordSystems[i].GetName() == name)
{
return this->CoordSystems[i];
}
}
throw vtkm::cont::ErrorControlBadValue(
"No coordinate system with requested name");
}
VTKM_CONT_EXPORT
void AddCellSet(vtkm::cont::DynamicCellSet cellSet)
{
@ -96,15 +116,29 @@ public:
}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfCellSets() const
vtkm::cont::DynamicCellSet GetCellSet(vtkm::Id index=0) const
{
return static_cast<vtkm::Id>(this->CellSets.size());
VTKM_ASSERT_CONT((index >= 0) &&
(index < this->GetNumberOfCellSets()));
return this->CellSets[static_cast<std::size_t>(index)];
}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfFields() const
vtkm::IdComponent GetNumberOfCellSets() const
{
return static_cast<vtkm::Id>(this->Fields.size());
return static_cast<vtkm::IdComponent>(this->CellSets.size());
}
VTKM_CONT_EXPORT
vtkm::IdComponent GetNumberOfFields() const
{
return static_cast<vtkm::IdComponent>(this->Fields.size());
}
VTKM_CONT_EXPORT
vtkm::IdComponent GetNumberOfCoordinateSystems() const
{
return static_cast<vtkm::IdComponent>(this->CoordSystems.size());
}
VTKM_CONT_EXPORT

200
vtkm/cont/DynamicArrayHandle.h
View File

@ -37,6 +37,10 @@ VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
// Forward declaration
template<typename TypeList, typename StorageList>
class DynamicArrayHandleBase;
namespace detail {
/// \brief Base class for PolymorphicArrayHandleContainer
@ -94,19 +98,24 @@ struct PolymorphicArrayHandleContainer
}
};
// One instance of a template class cannot access the private members of
// another instance of a template class. However, I want to be able to copy
// construct a DynamicArrayHandle from another DynamicArrayHandle of any other
// type. Since you cannot partially specialize friendship, use this accessor
// class to get at the internals for the copy constructor.
struct DynamicArrayHandleCopyHelper {
template<typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
static
boost::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>
GetArrayHandleContainer(const vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> &src)
{
return src.ArrayContainer;
}
};
} // namespace detail
namespace internal {
/// Behaves like (and is interchangable with) a DynamicArrayHandle. The
/// difference is that the list of types and list of storage to try when
/// calling CastAndCall is set to the class template arguments.
///
template<typename TypeList, typename StorageList>
class DynamicArrayHandleCast;
} // namespace internal
/// \brief Holds an array handle without having to specify template parameters.
///
/// \c DynamicArrayHandle holds an \c ArrayHandle object using runtime
@ -134,24 +143,38 @@ class DynamicArrayHandleCast;
/// combinations grows exponentially when using multiple \c DynamicArrayHandle
/// objects.
///
class DynamicArrayHandle
/// The actual implementation of \c DynamicArrayHandle is in a templated class
/// named \c DynamicArrayHandleBase, which is templated on the list of
/// component types and storage types. \c DynamicArrayHandle is really just a
/// typedef of \c DynamicArrayHandleBase with the default type and storage
/// lists.
///
template<typename TypeList, typename StorageList>
class DynamicArrayHandleBase
{
public:
VTKM_CONT_EXPORT
DynamicArrayHandle() { }
DynamicArrayHandleBase() { }
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
DynamicArrayHandle(const vtkm::cont::ArrayHandle<Type,Storage> &array)
DynamicArrayHandleBase(const vtkm::cont::ArrayHandle<Type,Storage> &array)
: ArrayContainer(new vtkm::cont::detail::PolymorphicArrayHandleContainer<
Type,Storage>(array))
{ }
template<typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
DynamicArrayHandle(
const internal::DynamicArrayHandleCast<TypeList,StorageList> &dynamicArray)
: ArrayContainer(dynamicArray.ArrayContainer) { }
DynamicArrayHandleBase(
const DynamicArrayHandleBase<TypeList,StorageList> &src)
: ArrayContainer(src.ArrayContainer) { }
template<typename OtherTypeList, typename OtherStorageList>
VTKM_CONT_EXPORT
explicit DynamicArrayHandleBase(
const DynamicArrayHandleBase<OtherTypeList,OtherStorageList> &src)
: ArrayContainer(
detail::DynamicArrayHandleCopyHelper::GetArrayHandleContainer(src))
{ }
/// Returns true if this array is of the provided type and uses the provided
/// storage.
@ -188,11 +211,10 @@ public:
///
template<typename NewTypeList>
VTKM_CONT_EXPORT
internal::DynamicArrayHandleCast<NewTypeList,VTKM_DEFAULT_STORAGE_LIST_TAG>
DynamicArrayHandleBase<NewTypeList,StorageList>
ResetTypeList(NewTypeList = NewTypeList()) const {
VTKM_IS_LIST_TAG(NewTypeList);
return internal::DynamicArrayHandleCast<
NewTypeList,VTKM_DEFAULT_STORAGE_LIST_TAG>(*this);
return DynamicArrayHandleBase<NewTypeList,StorageList>(*this);
}
/// Changes the array storage types to try casting to when resolving this
@ -204,34 +226,22 @@ public:
///
template<typename NewStorageList>
VTKM_CONT_EXPORT
internal::DynamicArrayHandleCast<VTKM_DEFAULT_TYPE_LIST_TAG,NewStorageList>
DynamicArrayHandleBase<TypeList,NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
VTKM_IS_LIST_TAG(NewStorageList);
return internal::DynamicArrayHandleCast<
VTKM_DEFAULT_TYPE_LIST_TAG,NewStorageList>(*this);
return DynamicArrayHandleBase<TypeList,NewStorageList>(*this);
}
/// Attempts to cast the held array to a specific value type and storage,
/// then call the given functor with the cast array. The types and storage
/// tried in the cast are those in the lists defined by
/// VTKM_DEFAULT_TYPE_LIST_TAG and VTK_DEFAULT_STORAGE_LIST_TAG,
/// respectively, unless they have been changed with a previous call to
/// ResetTypeList or ResetStorageList.
/// tried in the cast are those in the lists defined by the TypeList and
/// StorageList, respectively. The default \c DynamicArrayHandle sets these
/// two lists to VTKM_DEFAULT_TYPE_LIST_TAG and VTK_DEFAULT_STORAGE_LIST_TAG,
/// respectively.
///
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(
f, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());
}
/// A version of CastAndCall that tries specified lists of types and
/// storage types.
///
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, StorageList) const;
void CastAndCall(const Functor &f) const;
/// \brief Create a new array of the same type as this array.
///
@ -240,9 +250,9 @@ public:
/// creating output arrays that should be the same type as some input array.
///
VTKM_CONT_EXPORT
DynamicArrayHandle NewInstance() const
DynamicArrayHandleBase<TypeList,StorageList> NewInstance() const
{
DynamicArrayHandle newArray;
DynamicArrayHandleBase<TypeList,StorageList> newArray;
newArray.ArrayContainer = this->ArrayContainer->NewInstance();
return newArray;
}
@ -271,6 +281,8 @@ private:
boost::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>
ArrayContainer;
friend struct detail::DynamicArrayHandleCopyHelper;
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
vtkm::cont::detail::PolymorphicArrayHandleContainer<Type,Storage> *
@ -282,6 +294,10 @@ private:
}
};
typedef vtkm::cont::DynamicArrayHandleBase<
VTKM_DEFAULT_TYPE_LIST_TAG, VTKM_DEFAULT_STORAGE_LIST_TAG>
DynamicArrayHandle;
namespace detail {
template<typename Functor, typename Type>
@ -292,15 +308,20 @@ struct DynamicArrayHandleTryStorage {
VTKM_CONT_EXPORT
DynamicArrayHandleTryStorage(const DynamicArrayHandle &array,
const Functor &f)
const Functor &f)
: Array(array), Function(f), FoundCast(false) { }
template<typename Storage>
VTKM_CONT_EXPORT
typename boost::enable_if<
typename vtkm::cont::internal::IsValidArrayHandle<Type,Storage>::type
>::type
operator()(Storage) {
void operator()(Storage) {
this->DoCast(Storage(),
typename vtkm::cont::internal::IsValidArrayHandle<Type,Storage>::type());
}
private:
template<typename Storage>
void DoCast(Storage, boost::mpl::bool_<true>)
{
if (!this->FoundCast &&
this->Array.IsTypeAndStorage(Type(), Storage()))
{
@ -310,11 +331,8 @@ struct DynamicArrayHandleTryStorage {
}
template<typename Storage>
VTKM_CONT_EXPORT
typename boost::disable_if<
typename vtkm::cont::internal::IsValidArrayHandle<Type,Storage>::type
>::type
operator()(Storage) {
void DoCast(Storage, boost::mpl::bool_<false>)
{
// This type of array handle cannot exist, so do nothing.
}
};
@ -346,16 +364,19 @@ struct DynamicArrayHandleTryType {
} // namespace detail
template<typename Functor, typename TypeList, typename StorageList>
template<typename TypeList, typename StorageList>
template<typename Functor>
VTKM_CONT_EXPORT
void DynamicArrayHandle::CastAndCall(const Functor &f,
TypeList,
StorageList) const
void DynamicArrayHandleBase<TypeList,StorageList>::
CastAndCall(const Functor &f) const
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
typedef detail::DynamicArrayHandleTryType<Functor, StorageList> TryTypeType;
TryTypeType tryType = TryTypeType(*this, f);
// We cast this to a DynamicArrayHandle because at this point we are ignoring
// the type/storage lists in it. There is no sense in adding more unnecessary
// template cases.
TryTypeType tryType = TryTypeType(DynamicArrayHandle(*this), f);
vtkm::ListForEach(tryType, TypeList());
if (!tryType.FoundCast)
{
@ -366,72 +387,9 @@ void DynamicArrayHandle::CastAndCall(const Functor &f,
namespace internal {
template<typename TypeList, typename StorageList>
class DynamicArrayHandleCast : public vtkm::cont::DynamicArrayHandle
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
public:
VTKM_CONT_EXPORT
DynamicArrayHandleCast() : DynamicArrayHandle() { }
VTKM_CONT_EXPORT
DynamicArrayHandleCast(const vtkm::cont::DynamicArrayHandle &array)
: DynamicArrayHandle(array) { }
template<typename SrcTypeList, typename SrcStorageList>
VTKM_CONT_EXPORT
DynamicArrayHandleCast(
const DynamicArrayHandleCast<SrcTypeList,SrcStorageList> &array)
: DynamicArrayHandle(array) { }
template<typename NewTypeList>
VTKM_CONT_EXPORT
DynamicArrayHandleCast<NewTypeList,StorageList>
ResetTypeList(NewTypeList = NewTypeList()) const {
VTKM_IS_LIST_TAG(NewTypeList);
return DynamicArrayHandleCast<NewTypeList,StorageList>(*this);
}
template<typename NewStorageList>
VTKM_CONT_EXPORT
internal::DynamicArrayHandleCast<TypeList,NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
VTKM_IS_LIST_TAG(NewStorageList);
return internal::DynamicArrayHandleCast<TypeList,NewStorageList>(*this);
}
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(f, TypeList(), StorageList());
}
template<typename Functor, typename TL, typename CL>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TL, CL) const
{
this->DynamicArrayHandle::CastAndCall(f, TL(), CL());
}
VTKM_CONT_EXPORT
DynamicArrayHandleCast<TypeList,StorageList> NewInstance() const
{
return DynamicArrayHandleCast<TypeList,StorageList>(
this->DynamicArrayHandle::NewInstance());
}
};
template<>
struct DynamicTransformTraits<vtkm::cont::DynamicArrayHandle> {
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
template<typename TypeList, typename StorageList>
struct DynamicTransformTraits<
vtkm::cont::internal::DynamicArrayHandleCast<TypeList,StorageList> >
vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> >
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};

2
vtkm/cont/DynamicCellSet.h
View File

@ -83,7 +83,7 @@ struct DynamicCellSetCopyHelper {
/// combinations grows exponentially when using multiple \c Dynamic* objects.
///
/// The actual implementation of \c DynamicCellSet is in a templated class
/// names \c DynamicCellSetBase, which is templated on the list of cell set
/// named \c DynamicCellSetBase, which is templated on the list of cell set
/// types. \c DynamicCellSet is really just a typedef of \c DynamicCellSetBase
/// with the default cell set list.
///

413
vtkm/cont/DynamicPointCoordinates.h
View File

@ -1,413 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_DynamicPointCoordinates_h
#define vtk_m_cont_DynamicPointCoordinates_h
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/PointCoordinatesArray.h>
#include <vtkm/cont/PointCoordinatesListTag.h>
#include <vtkm/cont/internal/DynamicTransform.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/shared_ptr.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
namespace internal {
/// Behaves like (and is interchangable with) a \c DynamicPointCoordinates. The
/// difference is that the lists of point coordinates, base types, and
/// storage to try when calling \c CastAndCall is set to the class template
/// arguments.
///
template<typename PointCoordinatesList,
typename TypeList,
typename StorageList>
class DynamicPointCoordinatesCast;
} // namespace internal
/// \brief Holds point coordinates polymorphically.
///
/// The \c DynamicPointCoordinates holds a point coordinate field for a mesh.
/// Like a \c DynamicArrayHandle it contains a \c CastAndCall method that
/// allows it to interface with templated functions and will automatically be
/// converted on a worklet invoke.
///
/// \c DynamicPointCoordinates differes from \c DynamicArrayHandle in the type
/// of arrays it will check. Point coordinates are often defined as implicit
/// (uniform), semi-implicit (structured), unstructured, or some combination
/// thereof. Methods for defining point coordinates are captured in \c
/// PointCoordinates classes, and \c DynamicPointCoordinates polymorphically
/// stores one of these \c PointCoordinates objects.
///
/// By default, \c DynamicPointCoordinates will assume that the stored point
/// coordinates are of a type specified by \c
/// VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG. This can be overriden by using the
/// \c ResetPointCoordinatesList method.
///
/// Internally, some \c PointCoordinates objects will reference dynamic arrays.
/// Thus, \c DynamicPointCoordinates also maintains lists of types and
/// storage that these subarrays might use. These default to \c
/// VTKM_DEFAULT_TYPE_LIST_TAG and \c VTKM_DEFAULT_STORAGE_LIST_TAG and can
/// be changed with the \c ResetTypeList and \c ResetStorageList methods.
///
class DynamicPointCoordinates
{
public:
VTKM_CONT_EXPORT
DynamicPointCoordinates() { }
/// Special constructor for the common case of using a basic array to store
/// point coordinates.
///
VTKM_CONT_EXPORT
DynamicPointCoordinates(const vtkm::cont::DynamicArrayHandle &array)
: PointCoordinatesContainer(new vtkm::cont::PointCoordinatesArray(array))
{ }
/// Special constructor for the common case of using a basic array to store
/// point coordinates.
///
template<typename Storage>
VTKM_CONT_EXPORT
DynamicPointCoordinates(
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,3>,Storage> &array)
: PointCoordinatesContainer(new vtkm::cont::PointCoordinatesArray(array))
{ }
/// Special constructor for the common case of using a basic array to store
/// point coordinates.
///
template<typename Storage>
VTKM_CONT_EXPORT
DynamicPointCoordinates(
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float64,3>,Storage> &array)
: PointCoordinatesContainer(new vtkm::cont::PointCoordinatesArray(array))
{ }
/// Takes a concrete point coordinates class and stores it polymorphically.
/// Although the template will match any possible type, there is a check
/// to make sure that the type is a valid point coordinates class. If you get
/// a compile error in the check, follow the instantiation list to where the
/// constructor is called.
///
template<typename PointCoordinatesType>
VTKM_CONT_EXPORT
DynamicPointCoordinates(const PointCoordinatesType &pointCoordinates)
: PointCoordinatesContainer(new PointCoordinatesType(pointCoordinates))
{
VTKM_IS_POINT_COORDINATES(PointCoordinatesType);
}
/// Returns true if these point coordinates are stored in a \c
/// PointCoordinates class of the given type.
///
template<typename PointCoordinatesType>
VTKM_CONT_EXPORT
bool IsPointCoordinateType(PointCoordinatesType = PointCoordinatesType()) const
{
VTKM_IS_POINT_COORDINATES(PointCoordinatesType);
return (this->TryCastPointCoordinatesType<PointCoordinatesType>() != NULL);
}
/// Returns these point coordinates in a \c PointCoordinates class of the
/// given type. Throws \c ErrorControlBadValue if the cast does not work. Use
/// \c IsPointCoordinateType to check if the cast can happen.
///
template<typename PointCoordinatesType>
VTKM_CONT_EXPORT
const PointCoordinatesType &
CastToPointCoordinates(PointCoordinatesType = PointCoordinatesType()) const {
VTKM_IS_POINT_COORDINATES(PointCoordinatesType);
PointCoordinatesType *pointCoordinates =
this->TryCastPointCoordinatesType<PointCoordinatesType>();
if (pointCoordinates == NULL)
{
throw vtkm::cont::ErrorControlBadValue(
"Bad cast of dynamic point coordinates.");
}
return *pointCoordinates;
}
/// Changes the point coordinates objects to try casting to when resolving
/// dynamic arrays within the point coordinates container, which is specified
/// with a list tag like those in PointCoordinatesListTag.h. Since C++ does
/// not allow you to actually change the template arguments, this method
/// returns a new dynamic array object. This method is particularly useful to
/// narrow down (or expand) the types when using an array of particular
/// constraints.
///
template<typename NewPointCoordinatesList>
VTKM_CONT_EXPORT
internal::DynamicPointCoordinatesCast<
NewPointCoordinatesList,
VTKM_DEFAULT_TYPE_LIST_TAG,
VTKM_DEFAULT_STORAGE_LIST_TAG>
ResetPointCoordinatesList(
NewPointCoordinatesList = NewPointCoordinatesList()) const {
VTKM_IS_LIST_TAG(NewPointCoordinatesList);
return internal::DynamicPointCoordinatesCast<
NewPointCoordinatesList,
VTKM_DEFAULT_TYPE_LIST_TAG,
VTKM_DEFAULT_STORAGE_LIST_TAG>(*this);
}
/// Changes the types to try casting to when resolving dynamic arrays within
/// the point coordinates container, which is specified with a list tag like
/// those in TypeListTag.h. Since C++ does not allow you to actually change
/// the template arguments, this method returns a new dynamic array object.
/// This method is particularly useful to narrow down (or expand) the types
/// when using an array of particular constraints.
///
template<typename NewTypeList>
VTKM_CONT_EXPORT
internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
NewTypeList,
VTKM_DEFAULT_STORAGE_LIST_TAG>
ResetTypeList(NewTypeList = NewTypeList()) const {
VTKM_IS_LIST_TAG(NewTypeList);
return internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
NewTypeList,
VTKM_DEFAULT_STORAGE_LIST_TAG>(*this);
}
/// Changes the array storage to try casting to when resolving dynamic
/// arrays within the point coordinates container, which is specified with a
/// list tag like those in StorageListTag.h. Since C++ does not allow you
/// to actually change the template arguments, this method returns a new
/// dynamic array object. This method is particularly useful to narrow down
/// (or expand) the types when using an array of particular constraints.
///
template<typename NewStorageList>
VTKM_CONT_EXPORT
internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
VTKM_DEFAULT_TYPE_LIST_TAG,
NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
VTKM_IS_LIST_TAG(NewStorageList);
return internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
VTKM_DEFAULT_TYPE_LIST_TAG,
NewStorageList>(*this);
}
/// Attempts to cast the held point coordinates to a specific array
/// representation and then call the given functor with the cast array. This
/// is generally done in two parts. The first part finds the concrete type of
/// \c PointCoordinates object by trying all those in \c
/// VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG.
///
/// The second part then asks the concrete \c PointCoordinates object to cast
/// and call to a concrete array. This second cast might rely on \c
/// VTKM_DEFAULT_TYPE_LIST_TAG and \c VTKM_DEFAULT_STORAGE_LIST_TAG.
///
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(f,
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG(),
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
/// A version of \c CastAndCall that tries specified lists of point
/// coordinates, types, and storage.
///
template<typename Functor,
typename PointCoordinatesList,
typename TypeList,
typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f,
PointCoordinatesList,
TypeList,
StorageList) const;
private:
boost::shared_ptr<vtkm::cont::internal::PointCoordinatesBase>
PointCoordinatesContainer;
template<typename PointCoordinatesType>
VTKM_CONT_EXPORT
PointCoordinatesType *
TryCastPointCoordinatesType() const {
VTKM_IS_POINT_COORDINATES(PointCoordinatesType);
return dynamic_cast<PointCoordinatesType *>(
this->PointCoordinatesContainer.get());
}
};
namespace detail {
template<typename Functor, typename TypeList, typename StorageList>
struct DynamicPointCoordinatesTryStorage
{
const DynamicPointCoordinates PointCoordinates;
const Functor &Function;
bool FoundCast;
VTKM_CONT_EXPORT
DynamicPointCoordinatesTryStorage(
const DynamicPointCoordinates &pointCoordinates,
const Functor &f)
: PointCoordinates(pointCoordinates), Function(f), FoundCast(false)
{ }
template<typename PointCoordinatesType>
VTKM_CONT_EXPORT
void operator()(PointCoordinatesType) {
if (!this->FoundCast &&
this->PointCoordinates.IsPointCoordinateType(PointCoordinatesType()))
{
PointCoordinatesType pointCoordinates =
this->PointCoordinates.CastToPointCoordinates(PointCoordinatesType());
pointCoordinates.CastAndCall(this->Function, TypeList(), StorageList());
this->FoundCast = true;
}
}
};
} // namespace detail
template<typename Functor,
typename PointCoordinatesList,
typename TypeList,
typename StorageList>
VTKM_CONT_EXPORT
void DynamicPointCoordinates::CastAndCall(const Functor &f,
PointCoordinatesList,
TypeList,
StorageList) const
{
VTKM_IS_LIST_TAG(PointCoordinatesList);
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
typedef detail::DynamicPointCoordinatesTryStorage<
Functor, TypeList, StorageList> TryTypeType;
TryTypeType tryType = TryTypeType(*this, f);
vtkm::ListForEach(tryType, PointCoordinatesList());
if (!tryType.FoundCast)
{
throw vtkm::cont::ErrorControlBadValue(
"Could not find appropriate cast for point coordinates in CastAndCall.");
}
}
namespace internal {
template<typename PointCoordinatesList,
typename TypeList,
typename StorageList>
class DynamicPointCoordinatesCast : public vtkm::cont::DynamicPointCoordinates
{
VTKM_IS_LIST_TAG(PointCoordinatesList);
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
public:
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast() : DynamicPointCoordinates() { }
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast(const vtkm::cont::DynamicPointCoordinates &coords)
: DynamicPointCoordinates(coords) { }
template<typename SrcPointCoordinatesList,
typename SrcTypeList,
typename SrcStorageList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast(
const DynamicPointCoordinatesCast<SrcPointCoordinatesList,SrcTypeList,SrcStorageList> &coords)
: DynamicPointCoordinates(coords)
{ }
template<typename NewPointCoordinatesList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast<NewPointCoordinatesList,TypeList,StorageList>
ResetPointCoordinatesList(
NewPointCoordinatesList = NewPointCoordinatesList()) const {
VTKM_IS_LIST_TAG(NewPointCoordinatesList);
return DynamicPointCoordinatesCast<
NewPointCoordinatesList,TypeList,StorageList>(*this);
}
template<typename NewTypeList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast<PointCoordinatesList,NewTypeList,StorageList>
ResetTypeList(NewTypeList = NewTypeList()) const {
VTKM_IS_LIST_TAG(NewTypeList);
return DynamicPointCoordinatesCast<
PointCoordinatesList,NewTypeList,StorageList>(*this);
}
template<typename NewStorageList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast<PointCoordinatesList,TypeList,NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
VTKM_IS_LIST_TAG(NewStorageList);
return DynamicPointCoordinatesCast<
PointCoordinatesList,TypeList,NewStorageList>(*this);
}
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(f, PointCoordinatesList(), TypeList(), StorageList());
}
template<typename Functor, typename PCL, typename TL, typename CL>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, PCL, TL, CL) const
{
this->DynamicPointCoordinates::CastAndCall(f, PCL(), TL(), CL());
}
};
template<>
struct DynamicTransformTraits<vtkm::cont::DynamicPointCoordinates> {
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
template<typename PointCoordinatesList,
typename TypeList,
typename StorageList>
struct DynamicTransformTraits<
vtkm::cont::internal::DynamicPointCoordinatesCast<
PointCoordinatesList,TypeList,StorageList> >
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
} // namespace internal
}
} // namespace vtkm::cont
#endif //vtk_m_cont_DynamicPointCoordinates_h

75
vtkm/cont/Field.h
View File

@ -26,6 +26,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicArrayHandle.h>
@ -86,9 +87,11 @@ template<vtkm::IdComponent NumberOfComponents, typename ComputeBoundsClass>
class SelectNumberOfComponents
{
public:
static void Execute(vtkm::IdComponent components,
const vtkm::cont::DynamicArrayHandle &data,
ArrayHandle<vtkm::Float64> &bounds)
template<typename TypeList, typename StorageList>
static void Execute(
vtkm::IdComponent components,
const vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> &data,
ArrayHandle<vtkm::Float64> &bounds)
{
if (components == NumberOfComponents)
{
@ -108,7 +111,9 @@ template<typename ComputeBoundsClass>
class SelectNumberOfComponents<MAX_NUMBER_OF_COMPONENTS, ComputeBoundsClass>
{
public:
static void Execute(vtkm::Id, const vtkm::cont::DynamicArrayHandle&,
template<typename TypeList, typename StorageList>
static void Execute(vtkm::IdComponent,
const vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> &,
ArrayHandle<vtkm::Float64>&)
{
throw vtkm::cont::ErrorControlInternal(
@ -117,7 +122,7 @@ public:
};
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
template<typename DeviceAdapterTag>
class ComputeBounds
{
private:
@ -151,23 +156,55 @@ private:
}
}
// Special implementation for regular point coordinates, which are easy
// to determine.
void operator()(vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
array)
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
vtkm::Vec<vtkm::FloatDefault,3> minimum = portal.Get(0);
vtkm::Vec<vtkm::FloatDefault,3> maximum =
portal.Get(portal.GetNumberOfValues()-1);
this->Bounds->Allocate(6);
vtkm::cont::ArrayHandle<vtkm::Float64>::PortalControl outPortal =
this->Bounds->GetPortalControl();
outPortal.Set(0, minimum[0]);
outPortal.Set(1, maximum[0]);
outPortal.Set(2, minimum[1]);
outPortal.Set(3, maximum[1]);
outPortal.Set(4, minimum[2]);
outPortal.Set(5, maximum[2]);
}
private:
ArrayHandle<vtkm::Float64> *Bounds;
vtkm::cont::ArrayHandle<vtkm::Float64> *Bounds;
};
public:
template<vtkm::IdComponent NumberOfComponents>
static void CallBody(const vtkm::cont::DynamicArrayHandle &data,
template<vtkm::IdComponent NumberOfComponents,
typename TypeList,
typename StorageList>
static void CallBody(
const vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList> &data,
ArrayHandle<vtkm::Float64> &bounds)
{
Body<NumberOfComponents> cb(&bounds);
data.CastAndCall(cb, TypeList(), StorageList());
data.CastAndCall(cb);
}
static void DoCompute(const DynamicArrayHandle &data,
ArrayHandle<vtkm::Float64> &bounds)
template<typename TypeList, typename StorageList>
static void DoCompute(
const DynamicArrayHandleBase<TypeList,StorageList> &data,
ArrayHandle<vtkm::Float64> &bounds)
{
typedef ComputeBounds<DeviceAdapterTag, TypeList, StorageList> SelfType;
typedef ComputeBounds<DeviceAdapterTag> SelfType;
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
vtkm::IdComponent numberOfComponents = data.GetNumberOfComponents();
@ -186,7 +223,8 @@ public:
CallBody<4>(data, bounds);
break;
default:
SelectNumberOfComponents<5, SelfType>::Execute(numberOfComponents, data,
SelectNumberOfComponents<5, SelfType>::Execute(numberOfComponents,
data,
bounds);
break;
}
@ -205,6 +243,7 @@ public:
enum AssociationEnum
{
ASSOC_ANY,
ASSOC_WHOLE_MESH,
ASSOC_POINTS,
ASSOC_CELL_SET,
@ -216,7 +255,7 @@ public:
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
vtkm::cont::DynamicArrayHandle &data)
const vtkm::cont::DynamicArrayHandle &data)
: Name(name),
Order(order),
Association(association),
@ -235,7 +274,7 @@ public:
Field(std::string name,
vtkm::IdComponent order,
AssociationEnum association,
ArrayHandle<T, Storage> &data)
const ArrayHandle<T, Storage> &data)
: Name(name),
Order(order),
Association(association),
@ -533,8 +572,9 @@ public:
{
if (this->ModifiedFlag)
{
internal::ComputeBounds<DeviceAdapterTag, TypeList, StorageList>::DoCompute(
this->Data, this->Bounds);
internal::ComputeBounds<DeviceAdapterTag>::DoCompute(
this->Data.ResetTypeList(TypeList()).ResetStorageList(StorageList()),
this->Bounds);
this->ModifiedFlag = false;
}
@ -636,6 +676,7 @@ public:
out<<" assoc= ";
switch (this->GetAssociation())
{
case ASSOC_ANY: out<<"Any "; break;
case ASSOC_WHOLE_MESH: out<<"Mesh "; break;
case ASSOC_POINTS: out<<"Points "; break;
case ASSOC_CELL_SET: out<<"Cells "; break;

81
vtkm/cont/PointCoordinatesArray.h
View File

@ -1,81 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_PointCoordinatesArray_h
#define vtk_m_cont_PointCoordinatesArray_h
#include <vtkm/TypeListTag.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/internal/PointCoordinatesBase.h>
namespace vtkm {
namespace cont {
/// \brief Point coordinates stored in a \c Vector3 array.
///
/// The \c PointCoordinatesArray class is a simple PointCoordinates class
/// that stores the point coordinates in a single array. The array is managed
/// by a \c DynamicArrayHandle.
///
/// Like other PointCoordinates classes, \c PointCoordinatesArray is intended
/// to be used in conjunction with \c DynamicPointCoordinates.
///
class PointCoordinatesArray : public internal::PointCoordinatesBase
{
public:
VTKM_CONT_EXPORT
PointCoordinatesArray() { }
VTKM_CONT_EXPORT
PointCoordinatesArray(const vtkm::cont::DynamicArrayHandle &array)
: Array(array) { }
template<typename Storage>
VTKM_CONT_EXPORT
PointCoordinatesArray(
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,3>,Storage> &array)
: Array(array) { }
template<typename Storage>
VTKM_CONT_EXPORT
PointCoordinatesArray(
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float64,3>,Storage> &array)
: Array(array) { }
/// In this \c CastAndCall, \c TypeList is ignored. All point coordinates are
/// expressed as Vector3, so that must be how the array is represented.
///
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
this->Array.CastAndCall(f, vtkm::TypeListTagFieldVec3(), StorageList());
}
private:
vtkm::cont::DynamicArrayHandle Array;
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_PointCoordinatesArray_h

52
vtkm/cont/PointCoordinatesListTag.h
View File

@ -1,52 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_PointCoordinatesListTag_h
#define vtk_m_cont_PointCoordinatesListTag_h
#ifndef VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG
#define VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG \
::vtkm::cont::PointCoordinatesListTagCommon
#endif
#include <vtkm/ListTag.h>
#include <vtkm/cont/PointCoordinatesArray.h>
#include <vtkm/cont/PointCoordinatesUniform.h>
namespace vtkm {
namespace cont {
struct PointCoordinatesListTagArray :
vtkm::ListTagBase<vtkm::cont::PointCoordinatesArray> { };
struct PointCoordinatesListTagUniform :
vtkm::ListTagBase<vtkm::cont::PointCoordinatesUniform> { };
/// A list of the most commonly used point coordinate types. Includes \c
/// PointCoordinatesArray.
///
struct PointCoordinatesListTagCommon
: vtkm::ListTagBase<
vtkm::cont::PointCoordinatesArray,
vtkm::cont::PointCoordinatesUniform>
{ };
}
} // namespace vtkm::cont
#endif //vtk_m_cont_PointCoordinatesListTag_h

72
vtkm/cont/PointCoordinatesUniform.h
View File

@ -1,72 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_PointCoordinatesUniform_h
#define vtk_m_cont_PointCoordinatesUniform_h
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/internal/PointCoordinatesBase.h>
namespace vtkm {
namespace cont {
/// \brief Implicitly defined uniform point coordinates.
///
/// The \c PointCoordinatesUniform class is a PointCoordinates class that
/// implicitly defines the points for a uniform rectilinear grid of data
/// (defined by an extent, an origin, and spacing in each dimension).
///
/// Like other PointCoordinates classes, \c PointCoordinatesArray is intended
/// to be used in conjunction with \c DynamicPointCoordinates.
///
class PointCoordinatesUniform : public internal::PointCoordinatesBase
{
public:
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_CONT_EXPORT
PointCoordinatesUniform() { }
VTKM_CONT_EXPORT
PointCoordinatesUniform(const vtkm::Extent3 &extent,
const ValueType &origin,
const ValueType &spacing)
: Array(extent, origin, spacing)
{ }
/// In this \c CastAndCall, both \c TypeList and \c StorageList are
/// ignored. All point coordinates are expressed as Vector3, so that must be
/// how the array is represented.
///
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
f(this->Array);
}
private:
vtkm::cont::ArrayHandleUniformPointCoordinates Array;
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_PointCoordinatesUniform_h

11
vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx
View File

@ -23,7 +23,6 @@
#include "vtkm/cont/ArrayHandle.h"
#include "vtkm/cont/DynamicArrayHandle.h"
#include "vtkm/cont/DynamicCellSet.h"
#include "vtkm/cont/DynamicPointCoordinates.h"
#include "vtkm/internal/FunctionInterface.h"
@ -101,8 +100,7 @@ struct FunctionInterfaceFunctor {
void(vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<std::string>,
vtkm::cont::CellSetStructured<3>,
vtkm::cont::ArrayHandleUniformPointCoordinates)> &) const {
vtkm::cont::CellSetStructured<3>)> &) const {
std::cout << " In FunctionInterface<...> functor." << std::endl;
g_FunctionCalls++;
}
@ -152,7 +150,6 @@ void TestFunctionTransform()
vtkm::cont::ArrayHandle<vtkm::FloatDefault> scalarArray;
vtkm::cont::ArrayHandle<std::string> stringArray;
vtkm::cont::CellSetStructured<3> structuredCellSet;
vtkm::cont::ArrayHandleUniformPointCoordinates pointCoordinatesArray;
std::cout << " Trying basic functor call w/o transform (make sure it works)."
<< std::endl;
@ -161,8 +158,7 @@ void TestFunctionTransform()
scalarArray,
scalarArray,
stringArray,
structuredCellSet,
pointCoordinatesArray)));
structuredCellSet)));
std::cout << " Trying dynamic cast" << std::endl;
TRY_TRANSFORM(
@ -170,8 +166,7 @@ void TestFunctionTransform()
scalarArray,
vtkm::cont::DynamicArrayHandle(scalarArray),
vtkm::cont::DynamicArrayHandle(stringArray).ResetTypeList(TypeListTagString()),
vtkm::cont::DynamicCellSet(structuredCellSet),
vtkm::cont::DynamicPointCoordinates(vtkm::cont::PointCoordinatesUniform()))
vtkm::cont::DynamicCellSet(structuredCellSet))
.DynamicTransformCont(vtkm::cont::internal::DynamicTransform(),
FunctionInterfaceFunctor()));
}

2
vtkm/cont/testing/CMakeLists.txt
View File

@ -48,8 +48,6 @@ set(unit_tests
UnitTestDeviceAdapterSerial.cxx
UnitTestDynamicArrayHandle.cxx
UnitTestDynamicCellSet.cxx
UnitTestDynamicPointCoordinates.cxx
UnitTestPointCoordinates.cxx
UnitTestStorageBasic.cxx
UnitTestStorageImplicit.cxx
UnitTestStorageListTag.cxx

123
vtkm/cont/testing/MakeTestDataSet.h
View File

@ -21,6 +21,7 @@
#ifndef vtk_m_cont_testing_MakeTestDataSet_h
#define vtk_m_cont_testing_MakeTestDataSet_h
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/DataSet.h>
namespace vtkm {
@ -51,13 +52,12 @@ MakeTestDataSet::Make2DRegularDataSet0()
vtkm::cont::DataSet dataSet;
const int nVerts = 6;
vtkm::Float32 xVals[nVerts] = {0, 1, 2, 0, 1, 2};
vtkm::Float32 yVals[nVerts] = {0, 0, 0, 1, 1, 1};
vtkm::cont::ArrayHandleUniformPointCoordinates
coordinates(vtkm::Id3(3, 2, 1));
vtkm::Float32 vars[nVerts] = {10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f};
dataSet.AddField(Field("x", 1, vtkm::cont::Field::ASSOC_POINTS, xVals, nVerts));
dataSet.AddField(Field("y", 1, vtkm::cont::Field::ASSOC_POINTS, yVals, nVerts));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y"));
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 1, coordinates));
//set point scalar.
dataSet.AddField(Field("pointvar", 1, vtkm::cont::Field::ASSOC_POINTS, vars, nVerts));
@ -80,17 +80,14 @@ MakeTestDataSet::Make3DRegularDataSet0()
vtkm::cont::DataSet dataSet;
const int nVerts = 18;
vtkm::Float32 xVals[nVerts] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2};
vtkm::Float32 yVals[nVerts] = {0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1};
vtkm::Float32 zVals[nVerts] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2};
vtkm::cont::ArrayHandleUniformPointCoordinates
coordinates(vtkm::Id3(3, 2, 3));
vtkm::Float32 vars[nVerts] = {10.1f, 20.1f, 30.1f, 40.1f, 50.2f, 60.2f, 70.2f, 80.2f, 90.3f,
100.3f, 110.3f, 120.3f, 130.4f, 140.4f, 150.4f, 160.4f, 170.5f,
180.5f};
dataSet.AddField(Field("x", 1, vtkm::cont::Field::ASSOC_POINTS, xVals, nVerts));
dataSet.AddField(Field("y", 1, vtkm::cont::Field::ASSOC_POINTS, yVals, nVerts));
dataSet.AddField(Field("z", 1, vtkm::cont::Field::ASSOC_POINTS, zVals, nVerts));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y","z"));
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 1, coordinates));
//Set point scalar
dataSet.AddField(Field("pointvar", 1, vtkm::cont::Field::ASSOC_POINTS, vars, nVerts));
@ -113,15 +110,18 @@ MakeTestDataSet::Make3DExplicitDataSet0()
vtkm::cont::DataSet dataSet;
const int nVerts = 5;
vtkm::Float32 xVals[nVerts] = {0, 1, 1, 2, 2};
vtkm::Float32 yVals[nVerts] = {0, 0, 1, 1, 2};
vtkm::Float32 zVals[nVerts] = {0, 0, 0, 0, 0};
typedef vtkm::Vec<vtkm::Float32,3> CoordType;
CoordType coordinates[nVerts] = {
CoordType(0, 0, 0),
CoordType(1, 0, 0),
CoordType(1, 1, 0),
CoordType(2, 1, 0),
CoordType(2, 2, 0)
};
vtkm::Float32 vars[nVerts] = {10.1f, 20.1f, 30.2f, 40.2f, 50.3f};
dataSet.AddField(Field("x", 1, vtkm::cont::Field::ASSOC_POINTS, xVals, nVerts));
dataSet.AddField(Field("y", 1, vtkm::cont::Field::ASSOC_POINTS, yVals, nVerts));
dataSet.AddField(Field("z", 1, vtkm::cont::Field::ASSOC_POINTS, zVals, nVerts));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y","z"));
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 1, coordinates, nVerts));
//Set point scalar
dataSet.AddField(Field("pointvar", 1, vtkm::cont::Field::ASSOC_POINTS, vars, nVerts));
@ -164,15 +164,18 @@ MakeTestDataSet::Make3DExplicitDataSet1()
vtkm::cont::DataSet dataSet;
const int nVerts = 5;
vtkm::Float32 xVals[nVerts] = {0, 1, 1, 2, 2};
vtkm::Float32 yVals[nVerts] = {0, 0, 1, 1, 2};
vtkm::Float32 zVals[nVerts] = {0, 0, 0, 0, 0};
typedef vtkm::Vec<vtkm::Float32,3> CoordType;
CoordType coordinates[nVerts] = {
CoordType(0, 0, 0),
CoordType(1, 0, 0),
CoordType(1, 1, 0),
CoordType(2, 1, 0),
CoordType(2, 2, 0)
};
vtkm::Float32 vars[nVerts] = {10.1f, 20.1f, 30.2f, 40.2f, 50.3f};
dataSet.AddField(Field("x", 1, vtkm::cont::Field::ASSOC_POINTS, xVals, nVerts));
dataSet.AddField(Field("y", 1, vtkm::cont::Field::ASSOC_POINTS, yVals, nVerts));
dataSet.AddField(Field("z", 1, vtkm::cont::Field::ASSOC_POINTS, zVals, nVerts));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y","z"));
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 1, coordinates, nVerts));
//Set point scalar
dataSet.AddField(Field("pointvar", 1, vtkm::cont::Field::ASSOC_POINTS, vars, nVerts));
@ -199,33 +202,59 @@ MakeTestDataSet::Make3DExplicitDataSetCowNose(double *pBounds)
{
// prepare data array
const int nVerts = 17;
vtkm::Float64 xyzVals[nVerts][3] = {{0.0480879,0.151874,0.107334}, {0.0293568,0.245532,0.125337}, {0.0224398,0.246495,0.1351}, {0.0180085,0.20436,0.145316}, {0.0307091,0.152142,0.0539249}, {0.0270341,0.242992,0.107567}, {0.000684071,0.00272505,0.175648}, {0.00946217,0.077227,0.187097}, {-0.000168991,0.0692243,0.200755}, {-0.000129414,0.00247137,0.176561}, {0.0174172,0.137124,0.124553}, {0.00325994,0.0797155,0.184912}, {0.00191765,0.00589327,0.16608}, {0.0174716,0.0501928,0.0930275}, {0.0242103,0.250062,0.126256}, {0.0108188,0.152774,0.167914}, {5.41687e-05,0.00137834,0.175119}};
typedef vtkm::Vec<vtkm::Float64,3> CoordType;
CoordType coordinates[nVerts] = {
CoordType(0.0480879,0.151874,0.107334),
CoordType(0.0293568,0.245532,0.125337),
CoordType(0.0224398,0.246495,0.1351),
CoordType(0.0180085,0.20436,0.145316),
CoordType(0.0307091,0.152142,0.0539249),
CoordType(0.0270341,0.242992,0.107567),
CoordType(0.000684071,0.00272505,0.175648),
CoordType(0.00946217,0.077227,0.187097),
CoordType(-0.000168991,0.0692243,0.200755),
CoordType(-0.000129414,0.00247137,0.176561),
CoordType(0.0174172,0.137124,0.124553),
CoordType(0.00325994,0.0797155,0.184912),
CoordType(0.00191765,0.00589327,0.16608),
CoordType(0.0174716,0.0501928,0.0930275),
CoordType(0.0242103,0.250062,0.126256),
CoordType(0.0108188,0.152774,0.167914),
CoordType(5.41687e-05,0.00137834,0.175119)
};
const int nPointIds = 57;
vtkm::Id pointId[nPointIds] = {0, 1, 3, 2, 3, 1, 4, 5, 0, 1, 0, 5, 7, 8, 6, 9, 6, 8, 0, 10, 7, 11, 7, 10, 0, 6, 13, 12, 13, 6, 1, 5, 14, 1, 14, 2, 0, 3, 15, 0, 13, 4, 6, 16, 12, 6, 9, 16, 7, 11, 8, 0, 15, 10, 7, 6, 0};
vtkm::Id pointId[nPointIds] = {
0, 1, 3,
2, 3, 1,
4, 5, 0,
1, 0, 5,
7, 8, 6,
9, 6, 8,
0, 10, 7,
11, 7, 10,
0, 6, 13,
12, 13, 6,
1, 5, 14,
1, 14, 2,
0, 3, 15,
0, 13, 4,
6, 16, 12,
6, 9, 16,
7, 11, 8,
0, 15, 10,
7, 6, 0
};
double _bounds[6] = {-0.000169, 0.048088, 0.001378, 0.250062, 0.053925, 0.200755};
vtkm::Float32 xVals[nVerts], yVals[nVerts], zVals[nVerts];
vtkm::Vec<vtkm::Float32, 3> points[nVerts];
int i;
for (i=0; i<nVerts; i++)
{
points[i][0] = xVals[i] = (vtkm::Float32)xyzVals[i][0];
points[i][1] = yVals[i] = (vtkm::Float32)xyzVals[i][1];
points[i][2] = zVals[i] = (vtkm::Float32)xyzVals[i][2];
}
// create DataSet
vtkm::cont::DataSet dataSet;
dataSet.AddField(Field("xyz", 1, vtkm::cont::Field::ASSOC_POINTS, points, nVerts));
dataSet.AddField(Field("x", 1, vtkm::cont::Field::ASSOC_POINTS, xVals, nVerts));
dataSet.AddField(Field("y", 1, vtkm::cont::Field::ASSOC_POINTS, yVals, nVerts));
dataSet.AddField(Field("z", 1, vtkm::cont::Field::ASSOC_POINTS, zVals, nVerts));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y","z"));
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 1, coordinates, nVerts));
vtkm::cont::CellSetExplicit<> cellSet("cells", 2);
cellSet.PrepareToAddCells(nPointIds/3, nPointIds);
for (i=0; i<nPointIds/3; i++)
for (vtkm::Id i=0; i<nPointIds/3; i++)
{
cellSet.AddCell(vtkm::VTKM_TRIANGLE, 3, make_Vec<vtkm::Id>(pointId[i*3], pointId[i*3+1], pointId[i*3+2]));
}
@ -236,8 +265,12 @@ MakeTestDataSet::Make3DExplicitDataSetCowNose(double *pBounds)
// copy bounds
if (pBounds != NULL)
for (i=0; i<6; i++)
{
for (vtkm::IdComponent i=0; i<6; i++)
{
pBounds[i] = _bounds[i];
}
}
return dataSet;
}

24
vtkm/cont/testing/TestingComputeBounds.h
View File

@ -21,6 +21,7 @@
#define vtk_m_cont_testing_TestingComputeBounds_h
#include <vtkm/Types.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/testing/Testing.h>
@ -123,6 +124,26 @@ private:
}
}
static void TestUniformCoordinateField()
{
vtkm::cont::CoordinateSystem field(
"TestField",
1,
vtkm::Id3(10, 20, 5),
vtkm::Vec<vtkm::FloatDefault,3>(0.0f,-5.0f,4.0f),
vtkm::Vec<vtkm::FloatDefault,3>(1.0f,0.5f,2.0f));
vtkm::Float64 result[6];
field.GetBounds(result, DeviceAdapterTag());
VTKM_TEST_ASSERT(test_equal(result[0], 0.0), "Min x wrong.");
VTKM_TEST_ASSERT(test_equal(result[1], 9.0), "Max x wrong.");
VTKM_TEST_ASSERT(test_equal(result[2], -5.0), "Min y wrong.");
VTKM_TEST_ASSERT(test_equal(result[3], 4.5), "Max y wrong.");
VTKM_TEST_ASSERT(test_equal(result[4], 4.0), "Min z wrong.");
VTKM_TEST_ASSERT(test_equal(result[5], 12.0), "Max z wrong.");
}
struct TestAll
{
VTKM_CONT_EXPORT void operator()() const
@ -153,6 +174,9 @@ private:
TestingComputeBounds::TestVecField<vtkm::Float32, 9>();
std::cout << "Testing (Float64, 9)..." << std::endl;
TestingComputeBounds::TestVecField<vtkm::Float64, 9>();
std::cout << "Testing UniformPointCoords..." << std::endl;
TestingComputeBounds::TestUniformCoordinateField();
}
};

25
vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx
View File

@ -26,44 +26,41 @@ namespace {
typedef vtkm::Vec<vtkm::FloatDefault, 3> Vector3;
const vtkm::Id3 MIN_VALUES(-5, 8, 40);
const vtkm::Id3 MAX_VALUES(10, 25, 44);
const vtkm::Id3 POINT_DIMS(16, 18, 5);
const vtkm::Id3 DIMENSIONS(16, 18, 5);
const vtkm::Id NUM_POINTS = 1440;
const Vector3 ORIGIN(30, -3, -14);
const Vector3 ORIGIN(-20, 5, -10);
const Vector3 SPACING(10, 1, 0.1f);
const Vector3 LOWER_LEFT(-20, 5, -10); // MIN_VALUES*SPACING + ORIGIN
void TestArrayHandleUniformPointCoordinates()
{
std::cout << "Creating ArrayHandleUniformPointCoordinates" << std::endl;
vtkm::cont::ArrayHandleUniformPointCoordinates arrayHandle(
vtkm::Extent3(MIN_VALUES, MAX_VALUES), ORIGIN, SPACING);
DIMENSIONS, ORIGIN, SPACING);
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == NUM_POINTS,
"Array computed wrong number of points.");
std::cout << "Getting array portal." << std::endl;
vtkm::cont::internal::ArrayPortalUniformPointCoordinates portal =
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
arrayHandle.GetPortalConstControl();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == NUM_POINTS,
"Portal has wrong number of points.");
VTKM_TEST_ASSERT(portal.GetRange3() == POINT_DIMS,
VTKM_TEST_ASSERT(portal.GetRange3() == DIMENSIONS,
"Portal range is wrong.");
std::cout << "Checking computed values of portal." << std::endl;
Vector3 expectedValue;
vtkm::Id flatIndex = 0;
vtkm::Id3 blockIndex;
expectedValue[2] = LOWER_LEFT[2];
for (blockIndex[2] = 0; blockIndex[2] < POINT_DIMS[2]; blockIndex[2]++)
expectedValue[2] = ORIGIN[2];
for (blockIndex[2] = 0; blockIndex[2] < DIMENSIONS[2]; blockIndex[2]++)
{
expectedValue[1] = LOWER_LEFT[1];
for (blockIndex[1] = 0; blockIndex[1] < POINT_DIMS[1]; blockIndex[1]++)
expectedValue[1] = ORIGIN[1];
for (blockIndex[1] = 0; blockIndex[1] < DIMENSIONS[1]; blockIndex[1]++)
{
expectedValue[0] = LOWER_LEFT[0];
for (blockIndex[0] = 0; blockIndex[0] < POINT_DIMS[0]; blockIndex[0]++)
expectedValue[0] = ORIGIN[0];
for (blockIndex[0] = 0; blockIndex[0] < DIMENSIONS[0]; blockIndex[0]++)
{
VTKM_TEST_ASSERT(test_equal(expectedValue, portal.Get(flatIndex)),
"Got wrong value for flat index.");

32
vtkm/cont/testing/UnitTestDataSetExplicit.cxx
View File

@ -33,8 +33,38 @@ void TestDataSet_Explicit()
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 5,
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2,
"Incorrect number of fields");
// test various field-getting methods and associations
const vtkm::cont::Field &f1 = ds.GetField("pointvar");
VTKM_TEST_ASSERT(f1.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Association of 'pointvar' was not ASSOC_POINTS");
try
{
//const vtkm::cont::Field &f2 =
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
}
try
{
//const vtkm::cont::Field &f3 =
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS);
VTKM_TEST_FAIL("Failed to get expected error for association mismatch.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
std::cout << "Caught expected error for association mismatch: "
<< std::endl << " " << error.GetMessage() << std::endl;
}
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Incorrect number of coordinate systems");
}
}

315
vtkm/cont/testing/UnitTestDataSetRegular.cxx
View File

@ -34,162 +34,221 @@ static void ThreeDimRegularTest();
void TestDataSet_Regular()
{
std::cout << std::endl;
std::cout << "--TestDataSet_Regular--" << std::endl << std::endl;
std::cout << std::endl;
std::cout << "--TestDataSet_Regular--" << std::endl << std::endl;
TwoDimRegularTest();
ThreeDimRegularTest();
TwoDimRegularTest();
ThreeDimRegularTest();
}
static void
TwoDimRegularTest()
{
std::cout<<"2D Regular data set"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
std::cout<<"2D Regular data set"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make2DRegularDataSet0();
typedef vtkm::cont::CellSetStructured<2> CellSetType;
CellSetType cellSet = dataSet.GetCellSet(0).CastTo<CellSetType>();
typedef vtkm::cont::CellSetStructured<2> CellSetType;
CellSetType cellSet = dataSet.GetCellSet(0).CastTo<CellSetType>();
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 4,
"Incorrect number of fields");
VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 6,
"Incorrect number of points");
VTKM_TEST_ASSERT(cellSet.GetNumberOfCells() == 2,
"Incorrect number of cells");
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2,
"Incorrect number of fields");
VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
"Incorrect number of coordinate systems");
VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 6,
"Incorrect number of points");
VTKM_TEST_ASSERT(cellSet.GetNumberOfCells() == 2,
"Incorrect number of cells");
vtkm::Id numCells = cellSet.GetNumberOfCells();
for (vtkm::Id cellIndex = 0; cellIndex < numCells; cellIndex++)
// test various field-getting methods and associations
const vtkm::cont::Field &f1 = dataSet.GetField("pointvar");
VTKM_TEST_ASSERT(f1.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Association of 'pointvar' was not ASSOC_POINTS");
try
{
//const vtkm::cont::Field &f2 =
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
}
try
{
//const vtkm::cont::Field &f3 =
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS);
VTKM_TEST_FAIL("Failed to get expected error for association mismatch.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
std::cout << "Caught expected error for association mismatch: "
<< std::endl << " " << error.GetMessage() << std::endl;
}
vtkm::Id numCells = cellSet.GetNumberOfCells();
for (vtkm::Id cellIndex = 0; cellIndex < numCells; cellIndex++)
{
VTKM_TEST_ASSERT(cellSet.GetNumberOfPointsInCell(cellIndex) == 4,
"Incorrect number of cell indices");
vtkm::CellType shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::VTKM_PIXEL, "Incorrect element type.");
}
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
2> pointToCell =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagPoint(),
vtkm::TopologyElementTagCell());
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint,
2> cellToPoint =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagCell(),
vtkm::TopologyElementTagPoint());
vtkm::Id cells[2][4] = {{0,1,3,4}, {1,2,4,5}};
for (vtkm::Id cellIndex = 0; cellIndex < 2; cellIndex++)
{
vtkm::Vec<vtkm::Id,4> pointIds = pointToCell.GetIndices(cellIndex);
for (vtkm::IdComponent localPointIndex = 0;
localPointIndex < 4;
localPointIndex++)
{
VTKM_TEST_ASSERT(cellSet.GetNumberOfPointsInCell(cellIndex) == 4,
"Incorrect number of cell indices");
vtkm::CellType shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::VTKM_PIXEL, "Incorrect element type.");
VTKM_TEST_ASSERT(
pointIds[localPointIndex] == cells[cellIndex][localPointIndex],
"Incorrect point ID for cell");
}
}
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
2> pointToCell =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagPoint(),
vtkm::TopologyElementTagCell());
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint,
2> cellToPoint =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagCell(),
vtkm::TopologyElementTagPoint());
vtkm::Id expectedCellIds[6][4] = {{0,-1,-1,-1},
{0,1,-1,-1},
{0,-1,-1,-1},
{0,1,-1,-1},
{2,-1,-1,-1},
{2,3,-1,-1}};
vtkm::Id cells[2][4] = {{0,1,3,4}, {1,2,4,5}};
for (vtkm::Id cellIndex = 0; cellIndex < 2; cellIndex++)
{
vtkm::Vec<vtkm::Id,4> pointIds = pointToCell.GetIndices(cellIndex);
for (vtkm::IdComponent localPointIndex = 0;
localPointIndex < 4;
localPointIndex++)
{
VTKM_TEST_ASSERT(
pointIds[localPointIndex] == cells[cellIndex][localPointIndex],
"Incorrect point ID for cell");
}
}
vtkm::Id expectedCellIds[6][4] = {{0,-1,-1,-1},
{0,1,-1,-1},
{0,-1,-1,-1},
{0,1,-1,-1},
{2,-1,-1,-1},
{2,3,-1,-1}};
for (vtkm::Id pointIndex = 0; pointIndex < 6; pointIndex++)
{
vtkm::Vec<vtkm::Id,4> retrievedCellIds =
cellToPoint.GetIndices(pointIndex);
for (vtkm::IdComponent cellIndex = 0; cellIndex < 4; cellIndex++)
VTKM_TEST_ASSERT(
retrievedCellIds[cellIndex] == expectedCellIds[pointIndex][cellIndex],
"Incorrect cell ID for point");
}
for (vtkm::Id pointIndex = 0; pointIndex < 6; pointIndex++)
{
vtkm::Vec<vtkm::Id,4> retrievedCellIds =
cellToPoint.GetIndices(pointIndex);
for (vtkm::IdComponent cellIndex = 0; cellIndex < 4; cellIndex++)
VTKM_TEST_ASSERT(
retrievedCellIds[cellIndex] == expectedCellIds[pointIndex][cellIndex],
"Incorrect cell ID for point");
}
}
static void
ThreeDimRegularTest()
{
std::cout<<"3D Regular data set"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
std::cout<<"3D Regular data set"<<std::endl;
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DRegularDataSet0();
vtkm::cont::DataSet dataSet = testDataSet.Make3DRegularDataSet0();
typedef vtkm::cont::CellSetStructured<3> CellSetType;
CellSetType cellSet = dataSet.GetCellSet(0).CastTo<CellSetType>();
typedef vtkm::cont::CellSetStructured<3> CellSetType;
CellSetType cellSet = dataSet.GetCellSet(0).CastTo<CellSetType>();
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 5,
"Incorrect number of fields");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 2,
"Incorrect number of fields");
VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 18,
"Incorrect number of points");
VTKM_TEST_ASSERT(dataSet.GetNumberOfCoordinateSystems() == 1,
"Incorrect number of coordinate systems");
VTKM_TEST_ASSERT(cellSet.GetNumberOfCells() == 4,
"Incorrect number of cells");
VTKM_TEST_ASSERT(cellSet.GetNumberOfPoints() == 18,
"Incorrect number of points");
vtkm::Id numCells = cellSet.GetNumberOfCells();
for (vtkm::Id cellIndex = 0; cellIndex < numCells; cellIndex++)
{
VTKM_TEST_ASSERT(cellSet.GetNumberOfPointsInCell(cellIndex) == 8,
"Incorrect number of cell indices");
vtkm::CellType shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::VTKM_VOXEL, "Incorrect element type.");
}
VTKM_TEST_ASSERT(cellSet.GetNumberOfCells() == 4,
"Incorrect number of cells");
//Test regular connectivity.
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
3> pointToCell =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagPoint(),
vtkm::TopologyElementTagCell());
vtkm::Id expectedPointIds[8] = {0,1,3,4,6,7,9,10};
vtkm::Vec<vtkm::Id,8> retrievedPointIds = pointToCell.GetIndices(0);
for (vtkm::IdComponent localPointIndex = 0;
localPointIndex < 8;
localPointIndex++)
{
VTKM_TEST_ASSERT(
retrievedPointIds[localPointIndex] == expectedPointIds[localPointIndex],
"Incorrect point ID for cell");
}
// test various field-getting methods and associations
const vtkm::cont::Field &f1 = dataSet.GetField("pointvar");
VTKM_TEST_ASSERT(f1.GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Association of 'pointvar' was not ASSOC_POINTS");
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint,
3> cellToPoint =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagCell(),
vtkm::TopologyElementTagPoint());
vtkm::Id retrievedCellIds[6] = {0,-1,-1,-1,-1,-1};
vtkm::Vec<vtkm::Id,6> expectedCellIds = cellToPoint.GetIndices(0);
for (vtkm::IdComponent localPointIndex = 0;
localPointIndex < 6;
localPointIndex++)
{
VTKM_TEST_ASSERT(
expectedCellIds[localPointIndex] == retrievedCellIds[localPointIndex],
"Incorrect cell ID for point");
}
try
{
//const vtkm::cont::Field &f2 =
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
}
try
{
//const vtkm::cont::Field &f3 =
dataSet.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS);
VTKM_TEST_FAIL("Failed to get expected error for association mismatch.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
std::cout << "Caught expected error for association mismatch: "
<< std::endl << " " << error.GetMessage() << std::endl;
}
vtkm::Id numCells = cellSet.GetNumberOfCells();
for (vtkm::Id cellIndex = 0; cellIndex < numCells; cellIndex++)
{
VTKM_TEST_ASSERT(cellSet.GetNumberOfPointsInCell(cellIndex) == 8,
"Incorrect number of cell indices");
vtkm::CellType shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::VTKM_VOXEL, "Incorrect element type.");
}
//Test regular connectivity.
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
3> pointToCell =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagPoint(),
vtkm::TopologyElementTagCell());
vtkm::Id expectedPointIds[8] = {0,1,3,4,6,7,9,10};
vtkm::Vec<vtkm::Id,8> retrievedPointIds = pointToCell.GetIndices(0);
for (vtkm::IdComponent localPointIndex = 0;
localPointIndex < 8;
localPointIndex++)
{
VTKM_TEST_ASSERT(
retrievedPointIds[localPointIndex] == expectedPointIds[localPointIndex],
"Incorrect point ID for cell");
}
vtkm::exec::ConnectivityStructured<
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint,
3> cellToPoint =
cellSet.PrepareForInput(
vtkm::cont::DeviceAdapterTagSerial(),
vtkm::TopologyElementTagCell(),
vtkm::TopologyElementTagPoint());
vtkm::Id retrievedCellIds[6] = {0,-1,-1,-1,-1,-1};
vtkm::Vec<vtkm::Id,6> expectedCellIds = cellToPoint.GetIndices(0);
for (vtkm::IdComponent localPointIndex = 0;
localPointIndex < 6;
localPointIndex++)
{
VTKM_TEST_ASSERT(
expectedCellIds[localPointIndex] == retrievedCellIds[localPointIndex],
"Incorrect cell ID for point");
}
}
int UnitTestDataSetRegular(int, char *[])

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

@ -104,8 +104,10 @@ struct CheckFunctor
}
};
void BasicDynamicArrayChecks(const vtkm::cont::DynamicArrayHandle &array,
vtkm::IdComponent numComponents)
template<typename TypeList, typename StorageList>
void BasicDynamicArrayChecks(
const vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> &array,
vtkm::IdComponent numComponents)
{
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE,
"Dynamic array reports unexpected size.");
@ -126,7 +128,7 @@ void CheckDynamicArray(vtkm::cont::DynamicArrayHandle array,
template<typename TypeList, typename StorageList>
void CheckDynamicArray(
vtkm::cont::internal::DynamicArrayHandleCast<TypeList, StorageList> array,
vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList> array,
vtkm::IdComponent numComponents)
{
BasicDynamicArrayChecks(array, numComponents);

230
vtkm/cont/testing/UnitTestDynamicPointCoordinates.cxx
View File

@ -1,230 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/cont/DynamicPointCoordinates.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/StorageListTag.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
#include <vtkm/cont/testing/Testing.h>
#include <vector>
namespace {
const vtkm::Extent3 EXTENT = vtkm::Extent3(vtkm::Id3(0,0,0), vtkm::Id3(9,9,9));
const vtkm::Vec<vtkm::FloatDefault,3> ORIGIN =
vtkm::Vec<vtkm::FloatDefault,3>(0, 0, 0);
const vtkm::Vec<vtkm::FloatDefault,3> SPACING =
vtkm::Vec<vtkm::FloatDefault,3>(1, 1, 1);
const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
vtkm::Vec<vtkm::FloatDefault,3> ExpectedCoordinates(vtkm::Id index)
{
vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
return vtkm::make_Vec(vtkm::FloatDefault(index3d[0]),
vtkm::FloatDefault(index3d[1]),
vtkm::FloatDefault(index3d[2]));
}
int g_CheckArrayInvocations;
struct CheckArray
{
CheckArray() {
g_CheckArrayInvocations = 0;
}
template<typename ArrayType>
void operator()(const ArrayType &array) const
{
typedef typename ArrayType::ValueType ValueType;
std::cout << " In CastAndCall functor" << std::endl;
g_CheckArrayInvocations++;
typename ArrayType::PortalConstControl portal =
array.GetPortalConstControl();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,
"Array has wrong number of values.");
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
const ValueType receivedValue = portal.Get(index);
const ValueType expectedValue = ExpectedCoordinates(index);
VTKM_TEST_ASSERT(receivedValue == expectedValue,
"Got bad value in array.");
}
}
};
struct UnusualPortal
{
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; }
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id index) const { return ExpectedCoordinates(index); }
};
class ArrayHandleWithUnusualStorage
: public vtkm::cont::ArrayHandle<UnusualPortal::ValueType, vtkm::cont::StorageTagImplicit<UnusualPortal> >
{
typedef vtkm::cont::ArrayHandle<UnusualPortal::ValueType, vtkm::cont::StorageTagImplicit<UnusualPortal> >
Superclass;
public:
VTKM_CONT_EXPORT
ArrayHandleWithUnusualStorage()
: Superclass(Superclass::PortalConstControl()) { }
};
struct StorageListTagUnusual :
vtkm::ListTagBase<ArrayHandleWithUnusualStorage::StorageTag>
{ };
struct PointCoordinatesUnusual : vtkm::cont::internal::PointCoordinatesBase
{
template<typename Functor, typename TypeList, typename StorageList>
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
f(ArrayHandleWithUnusualStorage());
}
};
struct PointCoordinatesListUnusual
: vtkm::ListTagBase<PointCoordinatesUnusual> { };
struct TryDefaultArray
{
template<typename Vector3>
void operator()(Vector3) const
{
std::cout << "Trying basic point coordinates array with a default storage."
<< std::endl;
std::vector<Vector3> buffer( static_cast<vtkm::UInt32>(ARRAY_SIZE) );
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
vtkm::UInt32 i = static_cast< vtkm::UInt32 >(index);
buffer[i] = ExpectedCoordinates(index);
}
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(
vtkm::cont::make_ArrayHandle(buffer));
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
}
};
void TryUnusualStorage()
{
std::cout << "Trying a basic point coordinates array with an unusual storage."
<< std::endl;
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(
vtkm::cont::PointCoordinatesArray(ArrayHandleWithUnusualStorage()));
std::cout << " Make sure we get an exception when we can't find the type."
<< std::endl;
try
{
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
std::cout << " Caught expected exception for unrecognized storage: "
<< std::endl << " " << error.GetMessage() << std::endl;
}
std::cout << " Recast storage and try again." << std::endl;
pointCoordinates.ResetStorageList(StorageListTagUnusual())
.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
}
void TryUniformPointCoordinates()
{
std::cout << "Trying uniform point coordinates." << std::endl;
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(
vtkm::cont::PointCoordinatesUniform(EXTENT, ORIGIN, SPACING));
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
}
void TryUnusualPointCoordinates()
{
std::cout << "Trying an unusual point coordinates object." << std::endl;
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(PointCoordinatesUnusual());
std::cout << " Make sure we get an exception when we can't find the type."
<< std::endl;
try
{
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
std::cout << " Caught expected exception for unrecognized point coordinates: "
<< std::endl << " " << error.GetMessage() << std::endl;
}
std::cout << " Recast storage and try again." << std::endl;
pointCoordinates.ResetPointCoordinatesList(PointCoordinatesListUnusual())
.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
}
void DynamicPointCoordiantesTest()
{
vtkm::testing::Testing::TryTypes(TryDefaultArray(),
vtkm::TypeListTagFieldVec3());
TryUnusualStorage();
TryUniformPointCoordinates();
TryUnusualPointCoordinates();
}
} // anonymous namespace
int UnitTestDynamicPointCoordinates(int, char *[])
{
return vtkm::cont::testing::Testing::Run(DynamicPointCoordiantesTest);
}

144
vtkm/cont/testing/UnitTestPointCoordinates.cxx
View File

@ -1,144 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
// Make sure nothing relies on default storage or device adapter.
#define VTKM_STORAGE VTKM_STORAGE_ERROR
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_ERROR
// Make sure nothing relies on default lists.
#define VTKM_DEFAULT_TYPE_LIST_TAG ::vtkm::ListTagEmpty
#define VTKM_DEFAULT_STORAGE_LIST_TAG ::vtkm::ListTagEmpty
#include <vtkm/cont/PointCoordinatesArray.h>
#include <vtkm/cont/PointCoordinatesUniform.h>
#include <vtkm/Extent.h>
#include <vtkm/TypeListTag.h>
#include <vtkm/cont/DeviceAdapterSerial.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/testing/Testing.h>
#include <vector>
namespace {
const vtkm::Extent3 EXTENT = vtkm::Extent3(vtkm::Id3(0,0,0), vtkm::Id3(9,9,9));
const vtkm::Vec<vtkm::FloatDefault,3> ORIGIN =
vtkm::Vec<vtkm::FloatDefault,3>(0, 0, 0);
const vtkm::Vec<vtkm::FloatDefault,3> SPACING =
vtkm::Vec<vtkm::FloatDefault,3>(1, 1, 1);
const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
typedef vtkm::cont::StorageTagBasic StorageTag;
struct StorageListTag : vtkm::cont::StorageListTagBasic { };
vtkm::Vec<vtkm::FloatDefault,3> ExpectedCoordinates(vtkm::Id index)
{
vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
return vtkm::make_Vec(vtkm::FloatDefault(index3d[0]),
vtkm::FloatDefault(index3d[1]),
vtkm::FloatDefault(index3d[2]));
}
struct CheckArray
{
template<typename ArrayType>
void operator()(const ArrayType &array) const
{
typedef typename ArrayType::ValueType ValueType;
std::cout << " In CastAndCall functor" << std::endl;
typename ArrayType::PortalConstControl portal =
array.GetPortalConstControl();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,
"Array has wrong number of values.");
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
const ValueType receivedValue = portal.Get(index);
const ValueType expectedValue = ExpectedCoordinates(index);
VTKM_TEST_ASSERT(receivedValue == expectedValue,
"Got bad value in array.");
}
}
};
struct TestPointCoordinatesArray
{
template<typename Vector3>
void operator()(Vector3) const
{
std::cout << "Testing PointCoordinatesArray" << std::endl;
std::cout << " Creating buffer of data values" << std::endl;
std::vector<Vector3> buffer( static_cast<vtkm::UInt32>(ARRAY_SIZE) );
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
vtkm::UInt32 i = static_cast<vtkm::UInt32>(index);
buffer[i] = ExpectedCoordinates(index);
}
std::cout << " Creating and checking array handle" << std::endl;
vtkm::cont::ArrayHandle<Vector3,StorageTag> array =
vtkm::cont::make_ArrayHandle(buffer);
CheckArray()(array);
std::cout << " Creating and checking PointCoordinatesArray" << std::endl;
vtkm::cont::PointCoordinatesArray pointCoordinates =
vtkm::cont::PointCoordinatesArray(array);
pointCoordinates.CastAndCall(
CheckArray(),
vtkm::ListTagEmpty(), // Internally sets to Vector3
vtkm::cont::StorageListTagBasic());
}
};
void TestPointCoordinatesUniform()
{
std::cout << "Testing PointCoordinatesUniform" << std::endl;
vtkm::cont::PointCoordinatesUniform pointCoordinates =
vtkm::cont::PointCoordinatesUniform(EXTENT, ORIGIN, SPACING);
pointCoordinates.CastAndCall(
CheckArray(),
vtkm::ListTagEmpty(), // Not used
vtkm::ListTagEmpty()); // Not used
}
void PointCoordinatesTests()
{
vtkm::testing::Testing::TryTypes(TestPointCoordinatesArray(),
vtkm::TypeListTagFieldVec3());
TestPointCoordinatesUniform();
}
} // anonymous namespace
int UnitTestPointCoordinates(int, char *[])
{
return vtkm::cont::testing::Testing::Run(PointCoordinatesTests);
}

108
vtkm/internal/ArrayPortalUniformPointCoordinates.h Normal file
View File

@ -0,0 +1,108 @@
//============================================================================
// 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.
//
// Copyright 2015 Sandia Corporation.
// Copyright 2015 UT-Battelle, LLC.
// Copyright 2015 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_internal_ArrayPortalUniformPointCoordinates_h
#define vtk_m_internal_ArrayPortalUniformPointCoordinates_h
#include <vtkm/Types.h>
namespace vtkm {
namespace internal {
/// \brief An implicit array port that computes point coordinates for a uniform grid.
///
class ArrayPortalUniformPointCoordinates
{
public:
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates() : NumberOfValues(0) { }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates(vtkm::Id3 dimensions,
ValueType origin,
ValueType spacing)
: Dimensions(dimensions),
NumberOfValues(dimensions[0]*dimensions[1]*dimensions[2]),
Origin(origin),
Spacing(spacing)
{ }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates(
const ArrayPortalUniformPointCoordinates &src)
: Dimensions(src.Dimensions),
NumberOfValues(src.NumberOfValues),
Origin(src.Origin),
Spacing(src.Spacing)
{ }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates &
operator=(const ArrayPortalUniformPointCoordinates &src)
{
this->Dimensions = src.Dimensions;
this->NumberOfValues = src.NumberOfValues;
this->Origin = src.Origin;
this->Spacing = src.Spacing;
return *this;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return this->Get(
vtkm::Id3(index%this->Dimensions[0],
(index/this->Dimensions[0])%this->Dimensions[1],
index/(this->Dimensions[0]*this->Dimensions[1])));
}
VTKM_EXEC_CONT_EXPORT
vtkm::Id3 GetRange3() const { return this->Dimensions; }
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id3 index) const {
return ValueType(this->Origin[0] + this->Spacing[0] * static_cast<vtkm::FloatDefault>(index[0]),
this->Origin[1] + this->Spacing[1] * static_cast<vtkm::FloatDefault>(index[1]),
this->Origin[2] + this->Spacing[2] * static_cast<vtkm::FloatDefault>(index[2]));
}
VTKM_EXEC_CONT_EXPORT
const vtkm::Id3 &GetDimensions() const { return this->Dimensions; }
VTKM_EXEC_CONT_EXPORT
const ValueType &GetOrigin() const { return this->Origin; }
VTKM_EXEC_CONT_EXPORT
const ValueType &GetSpacing() const { return this->Spacing; }
private:
vtkm::Id3 Dimensions;
vtkm::Id NumberOfValues;
ValueType Origin;
ValueType Spacing;
};
}
} // namespace vtkm::internal
#endif //vtk_m_internal_ArrayPortalUniformPointCoordinates_h

1
vtkm/internal/CMakeLists.txt
View File

@ -19,6 +19,7 @@
##============================================================================
set(headers
ArrayPortalUniformPointCoordinates.h
ConfigureFor32.h
ConfigureFor64.h
ConnectivityStructuredInternals.h

18
vtkm/opengl/internal/TransferToOpenGL.h
View File

@ -35,24 +35,25 @@ namespace detail
template<class ValueType, class StorageTag, class DeviceAdapterTag>
VTKM_CONT_EXPORT
void CopyFromHandle(
void CopyFromHandle(
vtkm::cont::ArrayHandle<ValueType, StorageTag>& handle,
GLenum type,
DeviceAdapterTag)
{
//Generic implementation that will work no matter what. We copy the data
//in the given handle to a temporary handle using the basic storage tag.
//We then ensure the data is available in the control environment by
//We then ensure the data is available in the control environment by
//synchronizing the control array. Last, we steal the array and pass the
//iterator to the rendering system
const vtkm::Id numberOfValues = handle.GetNumberOfValues();
std::size_t size = sizeof(ValueType) * numberOfValues;
const std::size_t size =
sizeof(ValueType) * static_cast<std::size_t>(numberOfValues);
//Copy the data from its specialized Storage container to a basic storage
vtkm::cont::ArrayHandle<ValueType, vtkm::cont::StorageTagBasic> tmpHandle;
vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag>::Copy(handle, tmpHandle);
//Synchronize the arrays to ensure the most current data is available in the
//Synchronize the arrays to ensure the most current data is available in the
//control environment
tmpHandle.SyncControlArray();
@ -61,7 +62,7 @@ void CopyFromHandle(
//Detach the current buffer
glBufferData(type, size, 0, GL_DYNAMIC_DRAW);
//Allocate the memory and set it as static draw and copy into opengl
glBufferSubData(type,0,size,temporaryStorage);
@ -70,7 +71,7 @@ void CopyFromHandle(
template<class ValueType, class DeviceAdapterTag>
VTKM_CONT_EXPORT
void CopyFromHandle(
void CopyFromHandle(
vtkm::cont::ArrayHandle<ValueType, vtkm::cont::StorageTagBasic>& handle,
GLenum type,
DeviceAdapterTag)
@ -79,9 +80,10 @@ void CopyFromHandle(
//that allows us to directly hook into the data. We pull the data
//back to the control enviornment using PerpareForInput and give an iterator
//from the portal to OpenGL to upload to the rendering system
//This also works because we know that this class isn't used for cuda interop,
//This also works because we know that this class isn't used for cuda interop,
//instead we are specialized
std::size_t size = sizeof(ValueType) * handle.GetNumberOfValues();
const std::size_t size =
sizeof(ValueType) * static_cast<std::size_t>(handle.GetNumberOfValues());
//Detach the current buffer
glBufferData(type, size, 0, GL_DYNAMIC_DRAW);

25
vtkm/opengl/testing/TestingOpenGLInterop.h
View File

@ -61,7 +61,7 @@ private:
data.resize(length);
vtkm::Id pos = 0;
for(iterator i = data.begin(); i != data.end(); ++i, ++pos)
{ *i=T(pos); }
{ *i=TestValue(pos,T()); }
std::random_shuffle(data.begin(),data.end());
return vtkm::cont::make_ArrayHandle(data);
@ -131,7 +131,7 @@ private:
//get the size of the buffer
int bytesInBuffer = 0;
glGetBufferParameteriv(type, GL_BUFFER_SIZE, &bytesInBuffer);
int size = ( bytesInBuffer / sizeof(T) );
const std::size_t size = ( static_cast<std::size_t>(bytesInBuffer) / sizeof(T) );
//get the buffer contents and place it into a vector
std::vector<T> data;
@ -141,25 +141,12 @@ private:
return data;
}
//make a random value that we can test when loading constant values
template<typename T>
static
T MakeRandomValue(T)
{
return T(rand());
}
struct TransferFunctor
{
// std::size_t Size;
// GLuint GLHandle;
template <typename T>
void operator()(const T t) const
{
//this->Size = 10;
std::size_t Size = 10;
const std::size_t Size = 10;
GLuint GLHandle;
//verify that T is able to be transfer to openGL.
//than pull down the results from the array buffer and verify
@ -206,10 +193,10 @@ private:
"Array Handle failed to transfer properly");
}
//verify this work for a constant value array handle
T constantValue = MakeRandomValue(t);
vtkm::cont::ArrayHandleConstant<T> constant(constantValue, Size);
T constantValue = TestValue(2,T()); //verified by die roll
vtkm::cont::ArrayHandleConstant<T> constant(constantValue,
static_cast<vtkm::Id>(Size) );
SafelyTransferArray(constant,GLHandle);
is_buffer = glIsBuffer(GLHandle);
VTKM_TEST_ASSERT(is_buffer==true,

29
vtkm/worklet/PointElevation.h
View File

@ -23,6 +23,8 @@
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/Math.h>
namespace vtkm {
namespace worklet {
@ -32,7 +34,7 @@ template <typename T>
VTKM_EXEC_EXPORT
T clamp(const T& val, const T& min, const T& max)
{
return (val < min) ? min : ((val > max) ? max : val);
return vtkm::Min(max, vtkm::Max(min, val));
}
}
@ -40,9 +42,8 @@ T clamp(const T& val, const T& min, const T& max)
class PointElevation : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn<Scalar>, FieldIn<Scalar>, FieldIn<Scalar>,
FieldOut<Scalar>);
typedef void ExecutionSignature(_1, _2, _3, _4);
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
typedef _2 ExecutionSignature(_1);
VTKM_CONT_EXPORT
PointElevation() : LowPoint(0.0, 0.0, 0.0), HighPoint(0.0, 0.0, 1.0),
@ -67,18 +68,24 @@ public:
this->RangeHigh = high;
}
template <typename T1, typename T2, typename T3, typename T4>
VTKM_EXEC_EXPORT
void operator()(const T1 &x, const T2 &y, const T3 &z, T4 &elevation) const
vtkm::Float64 operator()(const vtkm::Vec<vtkm::Float64,3> &vec) const
{
vtkm::Vec<vtkm::Float64, 3> direction = this->HighPoint - this->LowPoint;
vtkm::Float64 length = vtkm::dot(direction, direction);
vtkm::Float64 lengthSqr = vtkm::dot(direction, direction);
vtkm::Float64 rangeLength = this->RangeHigh - this->RangeLow;
vtkm::Vec<vtkm::Float64, 3> vec = vtkm::make_Vec<vtkm::Float64>(x, y, z) -
this->LowPoint;
vtkm::Float64 s = vtkm::dot(vec, direction) / length;
vtkm::Float64 s = vtkm::dot(vec - this->LowPoint, direction) / lengthSqr;
s = internal::clamp(s, 0.0, 1.0);
elevation = static_cast<T4>(this->RangeLow + (s * rangeLength));
return this->RangeLow + (s * rangeLength);
}
template <typename T>
VTKM_EXEC_EXPORT
vtkm::Float64 operator()(const vtkm::Vec<T,3> &vec) const
{
return (*this)(vtkm::make_Vec(static_cast<vtkm::Float64>(vec[0]),
static_cast<vtkm::Float64>(vec[1]),
static_cast<vtkm::Float64>(vec[2])));
}
private:

32
vtkm/worklet/testing/UnitTestPointElevation.cxx
View File

@ -34,7 +34,7 @@ vtkm::cont::DataSet MakePointElevationTestDataSet()
{
vtkm::cont::DataSet dataSet;
std::vector<vtkm::Float32> xVals, yVals, zVals;
std::vector<vtkm::Vec<vtkm::Float32,3> > coordinates;
const vtkm::Id dim = 5;
for (vtkm::Id j = 0; j < dim; ++j)
{
@ -45,21 +45,13 @@ vtkm::cont::DataSet MakePointElevationTestDataSet()
vtkm::Float32 x = static_cast<vtkm::Float32>(i) /
static_cast<vtkm::Float32>(dim - 1);
vtkm::Float32 y = (x*x + z*z)/2.0f;
xVals.push_back(x);
yVals.push_back(y);
zVals.push_back(z);
coordinates.push_back(vtkm::make_Vec(x,y,z));
}
}
vtkm::Id numVerts = dim * dim;
vtkm::Id numCells = (dim - 1) * (dim - 1);
dataSet.AddField(vtkm::cont::Field("x", 1, vtkm::cont::Field::ASSOC_POINTS,
&xVals[0], numVerts));
dataSet.AddField(vtkm::cont::Field("y", 1, vtkm::cont::Field::ASSOC_POINTS,
&yVals[0], numVerts));
dataSet.AddField(vtkm::cont::Field("z", 1, vtkm::cont::Field::ASSOC_POINTS,
&zVals[0], numVerts));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("x","y","z"));
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 1, coordinates));
vtkm::cont::CellSetExplicit<> cellSet("cells", 3);
cellSet.PrepareToAddCells(numCells, numCells * 4);
@ -99,21 +91,19 @@ void TestPointElevation()
vtkm::worklet::DispatcherMapField<vtkm::worklet::PointElevation>
dispatcher(pointElevationWorklet);
dispatcher.Invoke(dataSet.GetField("x").GetData(),
dataSet.GetField("y").GetData(),
dataSet.GetField("z").GetData(),
dispatcher.Invoke(dataSet.GetCoordinateSystem().GetData(),
dataSet.GetField("elevation").GetData());
vtkm::cont::ArrayHandle<vtkm::Float32> yVals =
dataSet.GetField("y").GetData().CastToArrayHandle(vtkm::Float32(),
VTKM_DEFAULT_STORAGE_TAG());
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,3> > coordinates =
dataSet.GetCoordinateSystem().GetData().
CastToArrayHandle(vtkm::Vec<vtkm::Float32,3>(),VTKM_DEFAULT_STORAGE_TAG());
vtkm::cont::ArrayHandle<vtkm::Float32> result =
dataSet.GetField("elevation").GetData().CastToArrayHandle(vtkm::Float32(),
VTKM_DEFAULT_STORAGE_TAG());
dataSet.GetField("elevation").GetData().
CastToArrayHandle(vtkm::Float32(),VTKM_DEFAULT_STORAGE_TAG());
for (vtkm::Id i = 0; i < result.GetNumberOfValues(); ++i)
{
VTKM_TEST_ASSERT(test_equal(yVals.GetPortalConstControl().Get(i) * 2.0,
VTKM_TEST_ASSERT(test_equal(coordinates.GetPortalConstControl().Get(i)[1] * 2.0,
result.GetPortalConstControl().Get(i)),
"Wrong result for PointElevation worklet");
}

26
vtkm/worklet/testing/UnitTestVertexClustering.cxx
View File

@ -53,14 +53,14 @@ vtkm::cont::DataSet RunVertexClustering(vtkm::cont::DataSet &dataSet,
const vtkm::Float64 bounds[6],
vtkm::Id nDivisions)
{
typedef vtkm::Vec<vtkm::Float32,3> PointType;
typedef vtkm::Vec<vtkm::Float64,3> PointType;
// TODO: The VertexClustering operation needs some work. You should not have
// to cast the cell set yourself (I don't think).
vtkm::cont::CellSetExplicit<> &cellSet =
dataSet.GetCellSet(0).CastTo<vtkm::cont::CellSetExplicit<> >();
vtkm::cont::ArrayHandle<PointType> pointArray = dataSet.GetField("xyz").GetData().CastToArrayHandle<PointType, VTKM_DEFAULT_STORAGE_TAG>();
vtkm::cont::ArrayHandle<PointType> pointArray = dataSet.GetCoordinateSystem("coordinates").GetData().CastToArrayHandle<PointType, VTKM_DEFAULT_STORAGE_TAG>();
vtkm::cont::ArrayHandle<vtkm::Id> pointIdArray = cellSet.GetConnectivityArray();
vtkm::cont::ArrayHandle<vtkm::Id> indexOffsetArray = cellSet.GetIndexOffsetArray();
@ -79,8 +79,8 @@ vtkm::cont::DataSet RunVertexClustering(vtkm::cont::DataSet &dataSet,
vtkm::cont::DataSet newDataSet;
newDataSet.AddField(vtkm::cont::Field("xyz", 0, vtkm::cont::Field::ASSOC_POINTS, output_pointArray));
newDataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("xyz"));
newDataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", 0, output_pointArray));
vtkm::Id cells = output_pointId3Array.GetNumberOfValues();
if (cells > 0)
@ -116,17 +116,23 @@ void TestVertexClustering()
const vtkm::Id output_pointIds = 9;
vtkm::Id output_pointId[output_pointIds] = {0,1,3, 1,5,4, 1,2,5};
const vtkm::Id output_points = 6;
double output_point[output_points][3] = {{0.0174716003,0.0501927994,0.0930275023}, {0.0320714004,0.14704667,0.0952706337}, {0.0268670674,0.246195346,0.119720004}, {0.00215422804,0.0340906903,0.180881709}, {0.0108188,0.152774006,0.167914003}, {0.0202241503,0.225427493,0.140208006}};
vtkm::Float64 output_point[output_points][3] = {{0.0174716003,0.0501927994,0.0930275023}, {0.0320714004,0.14704667,0.0952706337}, {0.0268670674,0.246195346,0.119720004}, {0.00215422804,0.0340906903,0.180881709}, {0.0108188,0.152774006,0.167914003}, {0.0202241503,0.225427493,0.140208006}};
VTKM_TEST_ASSERT(outDataSet.GetNumberOfFields() == 1, "Number of output fields mismatch");
typedef vtkm::Vec<vtkm::Float32, 3> PointType;
VTKM_TEST_ASSERT(outDataSet.GetNumberOfCoordinateSystems() == 1,
"Number of output coordinate systems mismatch");
typedef vtkm::Vec<vtkm::Float64, 3> PointType;
typedef vtkm::cont::ArrayHandle<PointType > PointArray;
PointArray pointArray = outDataSet.GetField(0).GetData().CastToArrayHandle<PointArray::ValueType, PointArray::StorageTag>();
VTKM_TEST_ASSERT(pointArray.GetNumberOfValues() == output_points, "Number of output points mismatch" );
PointArray pointArray =
outDataSet.GetCoordinateSystem(0).GetData().
CastToArrayHandle<PointArray::ValueType, PointArray::StorageTag>();
VTKM_TEST_ASSERT(pointArray.GetNumberOfValues() == output_points,
"Number of output points mismatch" );
for (vtkm::Id i = 0; i < pointArray.GetNumberOfValues(); ++i)
{
const PointType &p1 = pointArray.GetPortalConstControl().Get(i);
PointType p2 = vtkm::make_Vec<vtkm::Float32>((vtkm::Float32)output_point[i][0], (vtkm::Float32)output_point[i][1], (vtkm::Float32)output_point[i][2]) ;
PointType p2 = vtkm::make_Vec(output_point[i][0],
output_point[i][1],
output_point[i][2]);
std::cout << "point: " << p1 << " " << p2 << std::endl;
VTKM_TEST_ASSERT(test_equal(p1, p2), "Point Array mismatch");
}

8
vtkm/worklet/testing/UnitTestWorkletMapTopologyExplicit.cxx
View File

@ -132,7 +132,7 @@ TestMaxPointOrCell()
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 6,
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3,
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_explicit::MaxPointOrCellValue >
@ -144,8 +144,8 @@ TestMaxPointOrCell()
//Make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
res = dataSet.GetField(5).GetData().CastToArrayHandle(vtkm::Float32(),
VTKM_DEFAULT_STORAGE_TAG());
res = dataSet.GetField("outcellvar").GetData().
CastToArrayHandle(vtkm::Float32(), VTKM_DEFAULT_STORAGE_TAG());
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 100.1f),
"Wrong result for PointToCellMax worklet");
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(1), 100.2f),
@ -173,7 +173,7 @@ TestAvgPointToCell()
VTKM_TEST_ASSERT(dataSet.GetNumberOfCellSets() == 1,
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 6,
VTKM_TEST_ASSERT(dataSet.GetNumberOfFields() == 3,
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_explicit::AveragePointToCellValue > dispatcher;

14
vtkm/worklet/testing/UnitTestWorkletMapTopologyRegular.cxx
View File

@ -131,7 +131,7 @@ TestMaxPointOrCell()
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfCellSets(), 1),
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 5),
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_regular::MaxPointOrCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("cellvar").GetData(),
@ -142,12 +142,12 @@ TestMaxPointOrCell()
// part more flexible.
dataSet.GetCellSet(0).ResetCellSetList(
vtkm::cont::CellSetListTagStructured2D()),
dataSet.GetField(4).GetData());
dataSet.GetField("outcellvar").GetData());
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
res = dataSet.GetField(4).GetData().CastToArrayHandle(vtkm::Float32(),
VTKM_DEFAULT_STORAGE_TAG());
res = dataSet.GetField("outcellvar").GetData().
CastToArrayHandle(vtkm::Float32(), VTKM_DEFAULT_STORAGE_TAG());
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 100.1f),
"Wrong result for MaxPointOrCell worklet");
@ -175,7 +175,7 @@ TestAvgPointToCell()
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfCellSets(), 1),
"Incorrect number of cell sets");
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 5),
VTKM_TEST_ASSERT(test_equal(dataSet.GetNumberOfFields(), 3),
"Incorrect number of fields");
vtkm::worklet::DispatcherMapTopology< ::test_regular::AveragePointToCellValue > dispatcher;
dispatcher.Invoke(dataSet.GetField("pointvar").GetData(),
@ -189,8 +189,8 @@ TestAvgPointToCell()
//make sure we got the right answer.
vtkm::cont::ArrayHandle<vtkm::Float32> res;
res = dataSet.GetField(4).GetData().CastToArrayHandle(vtkm::Float32(),
VTKM_DEFAULT_STORAGE_TAG());
res = dataSet.GetField("outcellvar").GetData().
CastToArrayHandle(vtkm::Float32(), VTKM_DEFAULT_STORAGE_TAG());
VTKM_TEST_ASSERT(test_equal(res.GetPortalConstControl().Get(0), 30.1f),
"Wrong result for PointToCellAverage worklet");