Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-30 18:50:59 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Fix deprecation warnings

Browse Source 
There was an error that caused deprecation warnings in VTK-m to be
suppressed, which meant that many uses of deprecated features went
unnoticed. This fixes those deprecation warnings.

The majority of the warnings were caused by the use of the deprecated
`Cast`, `CopyTo`, and `ResetTypes` methods of `UnknownArrayHandle` (or
`VariantArrayHandle`). Both `Cast` and `CopyTo` have been subsumed by
`AsArrayHandle` (to make the functionality more clear). `ResetTypes` now
requires a second template argument to define the storage types to try.

Also fixed some issues with `SerializableField` being deprecated.
This class is no longer necessary because `Field` can now be directly
serialized.
This commit is contained in:
Kenneth Moreland 2021-01-25 10:36:56 -07:00
parent b085cde358
commit 8b133288ce
107 changed files with 373 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/contour_tree/ContourTreeMesh2D.cxx
View File

@ -112,7 +112,7 @@ int main(int argc, char* argv[])
vtkm::cont::Field resultField = output.GetField("saddlePeak");
;
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
resultField.GetData().CopyTo(saddlePeak);
resultField.GetData().AsArrayHandle(saddlePeak);
return 0;
}

2
examples/contour_tree/ContourTreeMesh3D.cxx
View File

@ -113,7 +113,7 @@ int main(int argc, char* argv[])
vtkm::cont::Field resultField = output.GetField("saddlePeak");
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
resultField.GetData().CopyTo(saddlePeak);
resultField.GetData().AsArrayHandle(saddlePeak);
return 0;
}

7
examples/contour_tree_augmented/ContourTreeApp.cxx
View File

@ -762,14 +762,13 @@ int main(int argc, char* argv[])
if (numLevels > 0) // if compute isovalues
{
// Get the data values for computing the explicit branch decomposition
// TODO Can we cast the handle we get from GetData() instead of doing a CopyTo?
#ifdef WITH_MPI
vtkm::cont::ArrayHandle<ValueType> dataField;
result.GetPartitions()[0].GetField(0).GetData().CopyTo(dataField);
result.GetPartitions()[0].GetField(0).GetData().AsArrayHandle(dataField);
bool dataFieldIsSorted = true;
#else
vtkm::cont::ArrayHandle<ValueType> dataField;
useDataSet.GetField(0).GetData().CopyTo(dataField);
useDataSet.GetField(0).GetData().AsArrayHandle(dataField);
bool dataFieldIsSorted = false;
#endif
@ -844,7 +843,7 @@ int main(int argc, char* argv[])
//vtkm::cont::Field resultField = result.GetField();
//vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id> > saddlePeak;
//resultField.GetData().CopyTo(saddlePeak);
//resultField.GetData().AsArrayHandle(saddlePeak);
// Dump out contour tree for comparison
if (rank == 0 && printContourTree)

2
examples/ising/Ising.cxx
View File

@ -96,7 +96,7 @@ int main(int argc, char** argv)
auto dataSet = SpinField({ 5, 5 });
vtkm::cont::ArrayHandle<vtkm::Float32> spins;
dataSet.GetCellField("spins").GetData().CopyTo(spins);
dataSet.GetCellField("spins").GetData().AsArrayHandle(spins);
vtkm::rendering::Scene scene;
vtkm::rendering::Actor actor(dataSet.GetCellSet(),

9
examples/polyline_archimedean_helix/PolyLineArchimedeanHelix.cxx
View File

@ -66,10 +66,11 @@ void TubeThatSpiral(vtkm::FloatDefault radius, vtkm::Id numLineSegments, vtkm::I
// This generates a new pointset, and new cell set.
vtkm::cont::ArrayHandle<vtkm::Vec3f> tubePoints;
vtkm::cont::CellSetSingleType<> tubeCells;
tubeWorklet.Run(ds.GetCoordinateSystem().GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Vec3f>>(),
ds.GetCellSet(),
tubePoints,
tubeCells);
tubeWorklet.Run(
ds.GetCoordinateSystem().GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Vec3f>>(),
ds.GetCellSet(),
tubePoints,
tubeCells);
vtkm::cont::DataSet tubeDataset;
tubeDataset.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coords", tubePoints));

2
examples/redistribute_points/RedistributePoints.h
View File

@ -100,7 +100,7 @@ class Redistributor
vtkm::Id currentIdx) const
{
vtkm::cont::ArrayHandle<T> farray =
field.GetData().template Cast<vtkm::cont::ArrayHandle<T>>();
field.GetData().template AsArrayHandle<vtkm::cont::ArrayHandle<T>>();
vtkm::cont::Algorithm::CopySubRange(data, 0, data.GetNumberOfValues(), farray, currentIdx);
}
};

4
vtkm/cont/CellLocatorRectilinearGrid.cxx
View File

@ -95,7 +95,7 @@ const vtkm::exec::CellLocator* CellLocatorRectilinearGrid::PrepareForExecution(
this->PlaneSize,
this->RowSize,
this->GetCellSet().template Cast<Structured3DType>(),
this->GetCoordinates().GetData().template Cast<RectilinearType>());
this->GetCoordinates().GetData().template AsArrayHandle<RectilinearType>());
}
else
{
@ -107,7 +107,7 @@ const vtkm::exec::CellLocator* CellLocatorRectilinearGrid::PrepareForExecution(
this->PlaneSize,
this->RowSize,
this->GetCellSet().template Cast<Structured2DType>(),
this->GetCoordinates().GetData().template Cast<RectilinearType>());
this->GetCoordinates().GetData().template AsArrayHandle<RectilinearType>());
}
if (!success)
{

2
vtkm/cont/CellLocatorUniformGrid.cxx
View File

@ -53,7 +53,7 @@ void CellLocatorUniformGrid::Build()
throw vtkm::cont::ErrorBadType("Cells are not 2D or 3D structured type.");
}
UniformType uniformCoords = coords.GetData().Cast<UniformType>();
UniformType uniformCoords = coords.GetData().AsArrayHandle<UniformType>();
auto coordsPortal = uniformCoords.ReadPortal();
this->Origin = coordsPortal.GetOrigin();

2
vtkm/cont/CoordinateSystem.cxx
View File

@ -72,7 +72,7 @@ CoordinateSystem::GetData() const
VTKM_CONT vtkm::cont::CoordinateSystem::MultiplexerArrayType
CoordinateSystem::GetDataAsMultiplexer() const
{
return this->GetData().AsMultiplexer<MultiplexerArrayType>();
return this->GetData().AsArrayHandle<MultiplexerArrayType>();
}
VTKM_CONT

6
vtkm/cont/DataSet.h
View File

@ -338,7 +338,7 @@ public:
vtkmdiy::save(bb, numberOfFields);
for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
{
vtkmdiy::save(bb, vtkm::cont::SerializableField<FieldTypeList>(dataset.GetField(i)));
vtkmdiy::save(bb, dataset.GetField(i));
}
}
@ -364,9 +364,9 @@ public:
vtkmdiy::load(bb, numberOfFields);
for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
{
vtkm::cont::SerializableField<FieldTypeList> field;
vtkm::cont::Field field;
vtkmdiy::load(bb, field);
dataset.AddField(field.Field);
dataset.AddField(field);
}
}
};

15
vtkm/cont/testing/Testing.h
View File

@ -468,10 +468,8 @@ inline VTKM_CONT TestEqualResult test_equal_CellSets(const CellSet1& cellset1,
return result;
}
template <typename FieldTypeList = VTKM_DEFAULT_TYPE_LIST>
inline VTKM_CONT TestEqualResult test_equal_Fields(const vtkm::cont::Field& f1,
const vtkm::cont::Field& f2,
FieldTypeList fTtypes = FieldTypeList())
const vtkm::cont::Field& f2)
{
TestEqualResult result;
@ -487,8 +485,7 @@ inline VTKM_CONT TestEqualResult test_equal_Fields(const vtkm::cont::Field& f1,
return result;
}
result =
test_equal_ArrayHandles(f1.GetData().ResetTypes(fTtypes), f2.GetData().ResetTypes(fTtypes));
result = test_equal_ArrayHandles(f1.GetData(), f2.GetData());
if (!result)
{
result.PushMessage("data doesn't match");
@ -497,12 +494,10 @@ inline VTKM_CONT TestEqualResult test_equal_Fields(const vtkm::cont::Field& f1,
return result;
}
template <typename CellSetTypes = VTKM_DEFAULT_CELL_SET_LIST,
typename FieldTypeList = VTKM_DEFAULT_TYPE_LIST>
template <typename CellSetTypes = VTKM_DEFAULT_CELL_SET_LIST>
inline VTKM_CONT TestEqualResult test_equal_DataSets(const vtkm::cont::DataSet& ds1,
const vtkm::cont::DataSet& ds2,
CellSetTypes ctypes = CellSetTypes(),
FieldTypeList fTtypes = FieldTypeList())
CellSetTypes ctypes = CellSetTypes())
{
TestEqualResult result;
if (ds1.GetNumberOfCoordinateSystems() != ds2.GetNumberOfCoordinateSystems())
@ -537,7 +532,7 @@ inline VTKM_CONT TestEqualResult test_equal_DataSets(const vtkm::cont::DataSet&
}
for (vtkm::IdComponent i = 0; i < ds1.GetNumberOfFields(); ++i)
{
result = test_equal_Fields(ds1.GetField(i), ds2.GetField(i), fTtypes);
result = test_equal_Fields(ds1.GetField(i), ds2.GetField(i));
if (!result)
{
result.PushMessage(std::string("fields don't match at index ") + std::to_string(i));

2
vtkm/cont/testing/TestingCellLocatorRectilinearGrid.h
View File

@ -185,7 +185,7 @@ public:
vtkm::cont::ArrayHandle<bool> match;
vtkm::cont::Token token;
LocatorWorklet<DeviceAdapter> worklet(
bounds, dims, coords.GetData().template Cast<RectilinearType>(), token);
bounds, dims, coords.GetData().template AsArrayHandle<RectilinearType>(), token);
vtkm::worklet::DispatcherMapField<LocatorWorklet<DeviceAdapter>> dispatcher(worklet);
dispatcher.SetDevice(DeviceAdapter());

2
vtkm/cont/testing/TestingCellLocatorTwoLevel.h
View File

@ -97,7 +97,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims)
std::uniform_real_distribution<vtkm::FloatDefault> warpFactor(-0.10f, 0.10f);
auto inPointsPortal = uniformDs.GetCoordinateSystem()
.GetData()
.template Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>()
.template AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>()
.ReadPortal();
vtkm::cont::ArrayHandle<PointType> points;
points.Allocate(inPointsPortal.GetNumberOfValues());

4
vtkm/cont/testing/UnitTestPartitionedDataSet.cxx
View File

@ -124,9 +124,9 @@ void DataSet_Compare(vtkm::cont::DataSet& leftDataSet, vtkm::cont::DataSet& righ
for (vtkm::Id j = 0; j < leftDataSet.GetNumberOfFields(); j++)
{
vtkm::cont::ArrayHandle<vtkm::Float32> lDataArray;
leftDataSet.GetField(j).GetData().CopyTo(lDataArray);
leftDataSet.GetField(j).GetData().AsArrayHandle(lDataArray);
vtkm::cont::ArrayHandle<vtkm::Float32> rDataArray;
rightDataSet.GetField(j).GetData().CopyTo(rDataArray);
rightDataSet.GetField(j).GetData().AsArrayHandle(rDataArray);
VTKM_TEST_ASSERT(lDataArray == rDataArray, "field value info incorrect");
}
return;

2
vtkm/cont/testing/UnitTestSerializationDataSet.cxx
View File

@ -26,7 +26,7 @@ using DataSetWrapper = vtkm::cont::SerializableDataSet<FieldTypeList, CellSetTyp
VTKM_CONT void TestEqualDataSet(const DataSetWrapper& ds1, const DataSetWrapper& ds2)
{
VTKM_TEST_ASSERT(test_equal_DataSets(ds1.DataSet, ds2.DataSet, CellSetTypes{}, FieldTypeList{}));
VTKM_TEST_ASSERT(test_equal_DataSets(ds1.DataSet, ds2.DataSet, CellSetTypes{}));
}
void RunTest(const vtkm::cont::DataSet& ds)

4
vtkm/filter/ContourTreeUniformAugmented.hxx
View File

@ -299,7 +299,9 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(
currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
//const vtkm::cont::ArrayHandle<T,StorageType> &fieldData = currField.GetData().Cast<vtkm::cont::ArrayHandle<T,StorageType> >();
vtkm::cont::ArrayHandle<T> fieldData;
vtkm::cont::ArrayCopy(currField.GetData().template ResetTypes<vtkm::List<T>>(), fieldData);
vtkm::cont::ArrayCopy(
currField.GetData().template ResetTypes<vtkm::List<T>, VTKM_DEFAULT_STORAGE_LIST>(),
fieldData);
auto currContourTreeMesh = vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper::
ComputeLocalContourTreeMesh<T>(
this->MultiBlockTreeHelper->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal()

8
vtkm/filter/ContourTreeUniformDistributed.hxx
View File

@ -680,7 +680,9 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
auto currField =
currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
vtkm::cont::ArrayHandle<FieldType> fieldData;
vtkm::cont::ArrayCopy(currField.GetData().ResetTypes(vtkm::List<FieldType>{}), fieldData);
vtkm::cont::ArrayCopy(
currField.GetData().ResetTypes(vtkm::List<FieldType>{}, VTKM_DEFAULT_STORAGE_LIST{}),
fieldData);
// ... compute and store the actual mesh
localDataBlocks[bi]->ContourTreeMeshes.emplace_back(this->LocalBoundaryTrees[bi].VertexIndex,
@ -914,7 +916,9 @@ VTKM_CONT void ContourTreeUniformDistributed::DoPostExecute(
auto currField =
currBlock.GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
vtkm::cont::ArrayHandle<FieldType> fieldData;
vtkm::cont::ArrayCopy(currField.GetData().ResetTypes(vtkm::List<FieldType>{}), fieldData);
vtkm::cont::ArrayCopy(
currField.GetData().ResetTypes(vtkm::List<FieldType>{}, VTKM_DEFAULT_STORAGE_LIST{}),
fieldData);
auto localToGlobalIdRelabeler = vtkm::worklet::contourtree_augmented::mesh_dem::IdRelabeler(
this->MultiBlockSpatialDecomposition.LocalBlockOrigins.ReadPortal().Get(
blockData->BlockIndex),

8
vtkm/filter/FilterTraits.h
View File

@ -35,6 +35,14 @@ struct DeduceFilterFieldTypes
using PList = typename DerivedPolicy::FieldTypeList;
using TypeList = vtkm::ListIntersect<ListOfTypes, PList>;
};
template <typename DerivedPolicy, typename ListOfStorage>
struct DeduceFilterFieldStorage
{
using PList = typename DerivedPolicy::StorageList;
using StorageList = vtkm::ListAppend<ListOfStorage, PList>;
};
}
}

3
vtkm/filter/Histogram.hxx
View File

@ -86,7 +86,8 @@ public:
void SetLocalHistogram(vtkm::Id index, const vtkm::cont::Field& field)
{
this->SetLocalHistogram(index, field.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Id>>());
this->SetLocalHistogram(index,
field.GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>());
}
vtkm::cont::ArrayHandle<vtkm::Id> ReduceAll() const

3
vtkm/filter/ImageDifference.hxx
View File

@ -89,8 +89,7 @@ inline VTKM_CONT vtkm::cont::DataSet ImageDifference::DoExecute(
{
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Not performing average");
primaryOutput = primary;
secondaryOutput =
secondaryField.GetData().template Cast<vtkm::cont::ArrayHandle<T, StorageType>>();
secondaryField.GetData().AsArrayHandle(secondaryOutput);
}
if (this->PixelShiftRadius > 0)

34
vtkm/filter/PolicyBase.h
View File

@ -201,10 +201,12 @@ using ArrayHandleMultiplexerForStorageList = vtkm::cont::ArrayHandleMultiplexerF
/// passed to the `DoMapField` method of filters.
///
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::VariantArrayHandleBase<typename std::conditional<
std::is_same<typename DerivedPolicy::FieldTypeList, vtkm::ListUniversal>::value,
VTKM_DEFAULT_TYPE_LIST,
typename DerivedPolicy::FieldTypeList>::type>
VTKM_CONT vtkm::cont::UncertainArrayHandle<
typename std::conditional<
std::is_same<typename DerivedPolicy::FieldTypeList, vtkm::ListUniversal>::value,
VTKM_DEFAULT_TYPE_LIST,
typename DerivedPolicy::FieldTypeList>::type,
typename DerivedPolicy::StorageList>
ApplyPolicyFieldNotActive(const vtkm::cont::Field& field, vtkm::filter::PolicyBase<DerivedPolicy>)
{
// Policies are on their way out, but until they are we want to respect them. In the mean
@ -213,7 +215,7 @@ ApplyPolicyFieldNotActive(const vtkm::cont::Field& field, vtkm::filter::PolicyBa
std::is_same<typename DerivedPolicy::FieldTypeList, vtkm::ListUniversal>::value,
VTKM_DEFAULT_TYPE_LIST,
typename DerivedPolicy::FieldTypeList>::type;
return field.GetData().ResetTypes(TypeList());
return field.GetData().ResetTypes(TypeList{}, typename DerivedPolicy::StorageList{});
}
//-----------------------------------------------------------------------------
@ -235,7 +237,7 @@ ApplyPolicyFieldOfType(const vtkm::cont::Field& field,
T,
vtkm::ListAppend<typename FilterType::AdditionalFieldStorage,
typename DerivedPolicy::StorageList>>;
return field.GetData().AsMultiplexer<ArrayHandleMultiplexerType>();
return field.GetData().AsArrayHandle<ArrayHandleMultiplexerType>();
}
//-----------------------------------------------------------------------------
@ -255,7 +257,10 @@ ApplyPolicyFieldActive(const vtkm::cont::Field& field,
using FilterTypes = typename vtkm::filter::FilterTraits<FilterType>::InputFieldTypeList;
using TypeList =
typename vtkm::filter::DeduceFilterFieldTypes<DerivedPolicy, FilterTypes>::TypeList;
return field.GetData().ResetTypes(TypeList());
using FilterStorage = typename vtkm::filter::FilterTraits<FilterType>::AdditionalFieldStorage;
using StorageList =
typename vtkm::filter::DeduceFilterFieldStorage<DerivedPolicy, FilterStorage>::StorageList;
return field.GetData().ResetTypes(TypeList{}, StorageList{});
}
////-----------------------------------------------------------------------------
@ -361,19 +366,26 @@ VTKM_CONT vtkm::cont::DynamicCellSetBase<
}
//-----------------------------------------------------------------------------
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList>
MakeSerializableField(vtkm::filter::PolicyBase<DerivedPolicy>)
VTKM_DEPRECATED(1.6, "MakeSerializableField is no longer needed.")
VTKM_CONT
vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList> MakeSerializableField(
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return {};
}
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList>
MakeSerializableField(const vtkm::cont::Field& field, vtkm::filter::PolicyBase<DerivedPolicy>)
VTKM_DEPRECATED(1.6, "MakeSerializableField is no longer needed.")
VTKM_CONT
vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList> MakeSerializableField(
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return vtkm::cont::SerializableField<typename DerivedPolicy::FieldTypeList>{ field };
}
VTKM_DEPRECATED_SUPPRESS_END
template <typename DerivedPolicy>
VTKM_DEPRECATED(1.6, "MakeSerializableDataSet now takes the filter as an argument.")

5
vtkm/filter/particleadvection/DataSetIntegrator.h
View File

@ -44,9 +44,10 @@ public:
FieldHandle fieldArray;
if (fieldData.IsType<FieldHandle>())
fieldArray = fieldData.Cast<FieldHandle>();
fieldArray = fieldData.AsArrayHandle<FieldHandle>();
else
vtkm::cont::ArrayCopy(fieldData.ResetTypes<vtkm::TypeListFieldVec3>(), fieldArray);
vtkm::cont::ArrayCopy(
fieldData.ResetTypes<vtkm::TypeListFieldVec3, VTKM_DEFAULT_STORAGE_LIST>(), fieldArray);
this->Eval = std::shared_ptr<GridEvalType>(new GridEvalType(ds, fieldArray));
}

8
vtkm/filter/testing/UnitTestCellAverageFilter.cxx
View File

@ -30,7 +30,7 @@ void TestCellAverageRegular3D()
VTKM_TEST_ASSERT(result.HasCellField("avgvals") == true, "Result field not present.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetCellField("avgvals").GetData().CopyTo(resultArrayHandle);
result.GetCellField("avgvals").GetData().AsArrayHandle(resultArrayHandle);
{
vtkm::Float32 expected[4] = { 60.1875f, 70.2125f, 120.3375f, 130.3625f };
for (vtkm::Id i = 0; i < 4; ++i)
@ -49,7 +49,7 @@ void TestCellAverageRegular3D()
vtkm::cont::ArrayHandle<vtkm::Vec3f> resultPointArray;
vtkm::cont::Field resultPointField = result.GetCellField("avgpos");
resultPointField.GetData().CopyTo(resultPointArray);
resultPointField.GetData().AsArrayHandle(resultPointArray);
{
vtkm::FloatDefault expected[4][3] = {
{ 0.5f, 0.5f, 0.5f }, { 1.5f, 0.5f, 0.5f }, { 0.5f, 0.5f, 1.5f }, { 1.5f, 0.5f, 1.5f }
@ -81,7 +81,7 @@ void TestCellAverageRegular2D()
vtkm::cont::Field resultField = result.GetCellField("pointvar");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
resultField.GetData().CopyTo(resultArrayHandle);
resultField.GetData().AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[2] = { 30.1f, 40.1f };
for (int i = 0; i < 2; ++i)
{
@ -107,7 +107,7 @@ void TestCellAverageExplicit()
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
vtkm::cont::Field resultField = result.GetCellField("pointvar");
resultField.GetData().CopyTo(resultArrayHandle);
resultField.GetData().AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[2] = { 20.1333f, 35.2f };
for (int i = 0; i < 2; ++i)
{

4
vtkm/filter/testing/UnitTestCellMeasuresFilter.cxx
View File

@ -60,7 +60,9 @@ void TestCellMeasuresFilter(vtkm::cont::DataSet& dataset,
"Output field could not be found or was improper.");
vtkm::cont::CastAndCall(
result.ResetTypes(vtkm::TypeListFieldScalar{}), CheckCellMeasuresFunctor{}, expected);
result.ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
CheckCellMeasuresFunctor{},
expected);
}
void TestCellMeasures()

6
vtkm/filter/testing/UnitTestCellSetConnectivityFilter.cxx
View File

@ -39,7 +39,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Id> componentArray;
auto temp = output.GetField("component").GetData();
temp.CopyTo(componentArray);
temp.AsArrayHandle(componentArray);
using Algorithm = vtkm::cont::Algorithm;
Algorithm::Sort(componentArray);
@ -57,7 +57,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Id> componentArray;
auto temp = output.GetField("component").GetData();
temp.CopyTo(componentArray);
temp.AsArrayHandle(componentArray);
using Algorithm = vtkm::cont::Algorithm;
Algorithm::Sort(componentArray);
@ -74,7 +74,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Id> componentArray;
auto temp = output.GetField("component").GetData();
temp.CopyTo(componentArray);
temp.AsArrayHandle(componentArray);
using Algorithm = vtkm::cont::Algorithm;
Algorithm::Sort(componentArray);

4
vtkm/filter/testing/UnitTestCleanGrid.cxx
View File

@ -45,7 +45,7 @@ void TestUniformGrid(vtkm::filter::CleanGrid clean)
VTKM_TEST_ASSERT((cellIds == vtkm::Id4(1, 2, 5, 4)), "Bad cell ids: ", cellIds);
vtkm::cont::ArrayHandle<vtkm::Float32> outPointField;
outData.GetField("pointvar").GetData().CopyTo(outPointField);
outData.GetField("pointvar").GetData().AsArrayHandle(outPointField);
VTKM_TEST_ASSERT(outPointField.GetNumberOfValues() == 6,
"Wrong point field size: ",
outPointField.GetNumberOfValues());
@ -57,7 +57,7 @@ void TestUniformGrid(vtkm::filter::CleanGrid clean)
outPointField.ReadPortal().Get(1));
vtkm::cont::ArrayHandle<vtkm::Float32> outCellField;
outData.GetField("cellvar").GetData().CopyTo(outCellField);
outData.GetField("cellvar").GetData().AsArrayHandle(outCellField);
VTKM_TEST_ASSERT(outCellField.GetNumberOfValues() == 2, "Wrong cell field size.");
VTKM_TEST_ASSERT(test_equal(outCellField.ReadPortal().Get(0), 100.1),
"Bad cell field value",

2
vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx
View File

@ -68,7 +68,7 @@ void TestClipExplicit()
auto temp = outputData.GetField("scalars").GetData();
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
temp.CopyTo(resultArrayHandle);
temp.AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[7] = { 1, 2, 1, 0, 0.5, 0.5, 0.5 };
for (int i = 0; i < 7; ++i)

4
vtkm/filter/testing/UnitTestContourFilter.cxx
View File

@ -61,7 +61,7 @@ public:
//verify the cellvar result
vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArrayOut;
result.GetField("cellvar").GetData().CopyTo(cellFieldArrayOut);
result.GetField("cellvar").GetData().AsArrayHandle(cellFieldArrayOut);
vtkm::cont::Algorithm::Sort(cellFieldArrayOut);
{
@ -151,7 +151,7 @@ public:
dataSet.GetCellSet().CopyTo(cellSet);
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetPointField("gyroid").GetData().CopyTo(fieldArray);
dataSet.GetPointField("gyroid").GetData().AsArrayHandle(fieldArray);
vtkm::worklet::Contour isosurfaceFilter;
isosurfaceFilter.SetMergeDuplicatePoints(false);

4
vtkm/filter/testing/UnitTestContourFilterNormals.cxx
View File

@ -111,7 +111,7 @@ void TestNormals(const vtkm::cont::DataSet& dataset, bool structured)
mc.SetActiveField("pointvar");
auto result = mc.Execute(dataset);
result.GetField("normals").GetData().CopyTo(normals);
result.GetField("normals").GetData().AsArrayHandle(normals);
VTKM_TEST_ASSERT(normals.GetNumberOfValues() == numVerts,
"Wrong number of values in normals field");
@ -150,7 +150,7 @@ void TestNormals(const vtkm::cont::DataSet& dataset, bool structured)
}
result = mc.Execute(dataset);
result.GetField("normals").GetData().CopyTo(normals);
result.GetField("normals").GetData().AsArrayHandle(normals);
VTKM_TEST_ASSERT(normals.GetNumberOfValues() == numVerts,
"Wrong number of values in normals field");

4
vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx
View File

@ -87,7 +87,7 @@ public:
vtkm::cont::Field Result = result.GetField("saddlePeak");
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
Result.GetData().CopyTo(saddlePeak);
Result.GetData().AsArrayHandle(saddlePeak);
VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 7),
"Wrong result for ContourTree filter");
@ -126,7 +126,7 @@ public:
vtkm::cont::Field Result = result.GetField("saddlePeak");
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
Result.GetData().CopyTo(saddlePeak);
Result.GetData().AsArrayHandle(saddlePeak);
VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 9),
"Wrong result for ContourTree filter");

2
vtkm/filter/testing/UnitTestCrossProductFilter.cxx
View File

@ -79,7 +79,7 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec3f>& field1,
VTKM_TEST_ASSERT(result.HasPointField("crossproduct"), "Output field is missing.");
vtkm::cont::ArrayHandle<vtkm::Vec3f> outputArray;
result.GetPointField("crossproduct").GetData().CopyTo(outputArray);
result.GetPointField("crossproduct").GetData().AsArrayHandle(outputArray);
auto v1Portal = field1.ReadPortal();
auto v2Portal = field2.ReadPortal();

2
vtkm/filter/testing/UnitTestDotProductFilter.cxx
View File

@ -79,7 +79,7 @@ void CheckResult(const vtkm::cont::ArrayHandle<vtkm::Vec3f>& field1,
VTKM_TEST_ASSERT(result.HasPointField("dotproduct"), "Output field is missing.");
vtkm::cont::ArrayHandle<vtkm::FloatDefault> outputArray;
result.GetPointField("dotproduct").GetData().CopyTo(outputArray);
result.GetPointField("dotproduct").GetData().AsArrayHandle(outputArray);
auto v1Portal = field1.ReadPortal();
auto v2Portal = field2.ReadPortal();

2
vtkm/filter/testing/UnitTestEntropyFilter.cxx
View File

@ -33,7 +33,7 @@ void TestEntropy()
///// get entropy from resultEntropy /////
vtkm::cont::ArrayHandle<vtkm::Float64> entropy;
resultEntropy.GetField("entropy").GetData().CopyTo(entropy);
resultEntropy.GetField("entropy").GetData().AsArrayHandle(entropy);
vtkm::cont::ArrayHandle<vtkm::Float64>::ReadPortalType portal = entropy.ReadPortal();
vtkm::Float64 entropyFromFilter = portal.Get(0);

8
vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx
View File

@ -42,7 +42,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 8), "Wrong result for ExtractGeometry");
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 21.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(7) == 42.f, "Wrong cell field data");
@ -69,7 +69,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 56), "Wrong result for ExtractGeometry");
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 0.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(55) == 63.f, "Wrong cell field data");
@ -96,7 +96,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 64), "Wrong result for ExtractGeometry");
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 0.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(63) == 63.f, "Wrong cell field data");
@ -122,7 +122,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 56), "Wrong result for ExtractGeometry");
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(0) == 0.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outCellData.ReadPortal().Get(55) == 63.f, "Wrong cell field data");

4
vtkm/filter/testing/UnitTestExtractPointsFilter.cxx
View File

@ -41,7 +41,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 27), "Wrong result for ExtractPoints");
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -71,7 +71,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 98), "Wrong result for ExtractPoints");
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),

48
vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx
View File

@ -41,9 +41,9 @@ public:
"Wrong result for ExtractStructured worklet");
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -78,8 +78,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -116,8 +116,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -153,8 +153,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -190,8 +190,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -228,8 +228,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -266,8 +266,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -304,8 +304,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -342,8 +342,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -379,8 +379,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -418,8 +418,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),
@ -455,8 +455,8 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> outPointData;
vtkm::cont::ArrayHandle<vtkm::Float32> outCellData;
output.GetField("pointvar").GetData().CopyTo(outPointData);
output.GetField("cellvar").GetData().CopyTo(outCellData);
output.GetField("pointvar").GetData().AsArrayHandle(outPointData);
output.GetField("cellvar").GetData().AsArrayHandle(outCellData);
VTKM_TEST_ASSERT(
test_equal(output.GetCellSet().GetNumberOfPoints(), outPointData.GetNumberOfValues()),

4
vtkm/filter/testing/UnitTestFieldToColors.cxx
View File

@ -40,7 +40,7 @@ void TestFieldToColors()
VTKM_TEST_ASSERT(rgbaResult.HasPointField("colors"), "Field missing.");
vtkm::cont::Field Result = rgbaResult.GetPointField("colors");
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> resultRGBAHandle;
Result.GetData().CopyTo(resultRGBAHandle);
Result.GetData().AsArrayHandle(resultRGBAHandle);
//values confirmed with ParaView 5.4
const vtkm::Vec4ui_8 correct_diverging_rgba_values[nvals] = {
@ -61,7 +61,7 @@ void TestFieldToColors()
VTKM_TEST_ASSERT(rgbResult.HasPointField("colors"), "Field missing.");
Result = rgbResult.GetPointField("colors");
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> resultRGBHandle;
Result.GetData().CopyTo(resultRGBHandle);
Result.GetData().AsArrayHandle(resultRGBHandle);
//values confirmed with ParaView 5.4
const vtkm::Vec3ui_8 correct_diverging_rgb_values[nvals] = { { 0, 0, 255 }, { 59, 76, 192 },

2
vtkm/filter/testing/UnitTestGhostCellClassify.cxx
View File

@ -114,7 +114,7 @@ void TestStructured()
//Check the number of normal cells.
vtkm::cont::ArrayHandle<vtkm::UInt8> ghostArray;
fieldArray.CopyTo(ghostArray);
fieldArray.AsArrayHandle(ghostArray);
vtkm::Id numNormalCells = 0;
auto portal = ghostArray.ReadPortal();

4
vtkm/filter/testing/UnitTestGradientExplicit.cxx
View File

@ -32,7 +32,7 @@ void TestCellGradientExplicit()
VTKM_TEST_ASSERT(result.HasCellField("gradient"), "Result field missing.");
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> resultArrayHandle;
result.GetCellField("gradient").GetData().CopyTo(resultArrayHandle);
result.GetCellField("gradient").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Vec3f_32 expected[2] = { { 10.f, 10.1f, 0.0f }, { 10.f, 10.1f, -0.0f } };
for (int i = 0; i < 2; ++i)
{
@ -58,7 +58,7 @@ void TestPointGradientExplicit()
VTKM_TEST_ASSERT(result.HasPointField("gradient"), "Result field missing.");
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> resultArrayHandle;
result.GetPointField("gradient").GetData().CopyTo(resultArrayHandle);
result.GetPointField("gradient").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Vec3f_32 expected[2] = { { 10.f, 10.1f, 0.0f }, { 10.f, 10.1f, 0.0f } };
for (int i = 0; i < 2; ++i)

4
vtkm/filter/testing/UnitTestGradientUniform.cxx
View File

@ -81,7 +81,7 @@ void TestCellGradientUniform3DWithVectorField()
"vec gradients should generate qcriterion");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>> resultArrayHandle;
result.GetCellField("vec_gradient").GetData().CopyTo(resultArrayHandle);
result.GetCellField("vec_gradient").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Vec<vtkm::Vec3f_64, 3> expected[4] = {
{ { 10.025, 10.025, 10.025 }, { 30.075, 30.075, 30.075 }, { 60.125, 60.125, 60.125 } },
{ { 10.025, 10.025, 10.025 }, { 30.075, 30.075, 30.075 }, { 60.125, 60.125, 60.125 } },
@ -133,7 +133,7 @@ void TestPointGradientUniform3DWithVectorField()
VTKM_TEST_ASSERT(result.HasPointField("vec_gradient"), "Result field missing.");
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>> resultArrayHandle;
result.GetPointField("vec_gradient").GetData().CopyTo(resultArrayHandle);
result.GetPointField("vec_gradient").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Vec<vtkm::Vec3f_64, 3> expected[4] = {
{ { 10.0, 10.0, 10.0 }, { 30.0, 30.0, 30.0 }, { 60.1, 60.1, 60.1 } },
{ { 10.0, 10.0, 10.0 }, { 30.1, 30.1, 30.1 }, { 60.1, 60.1, 60.1 } },

2
vtkm/filter/testing/UnitTestHistogramFilter.cxx
View File

@ -262,7 +262,7 @@ void VerifyHistogram(const vtkm::cont::DataSet& result,
VTKM_TEST_ASSERT(result.HasField("histogram"), "Output field missing");
vtkm::cont::ArrayHandle<vtkm::Id> bins;
result.GetField("histogram").GetData().CopyTo(bins);
result.GetField("histogram").GetData().AsArrayHandle(bins);
vtkm::cont::ArrayHandle<vtkm::Id>::ReadPortalType binPortal = bins.ReadPortal();

2
vtkm/filter/testing/UnitTestImageConnectivityFilter.cxx
View File

@ -46,7 +46,7 @@ void TestImageConnectivity()
auto temp = outputData.GetField("component").GetData();
vtkm::cont::ArrayHandle<vtkm::Id> resultArrayHandle;
temp.CopyTo(resultArrayHandle);
temp.AsArrayHandle(resultArrayHandle);
std::vector<vtkm::Id> componentExpected = { 0, 1, 1, 1, 0, 1, 1, 2, 0, 0, 0, 1, 0, 1, 1, 2,
0, 1, 1, 0, 0, 1, 1, 2, 0, 1, 0, 0, 0, 1, 1, 2,

4
vtkm/filter/testing/UnitTestImageDifferenceFilter.cxx
View File

@ -45,8 +45,8 @@ void CheckResult(const std::vector<vtkm::Vec4f>& expectedDiff,
vtkm::cont::ArrayHandle<vtkm::Vec4f> outputArray;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> thresholdArray;
output.GetPointField("image-diff").GetData().CopyTo(outputArray);
output.GetPointField("threshold-output").GetData().CopyTo(thresholdArray);
output.GetPointField("image-diff").GetData().AsArrayHandle(outputArray);
output.GetPointField("threshold-output").GetData().AsArrayHandle(thresholdArray);
VTKM_TEST_ASSERT(outputArray.GetNumberOfValues() == static_cast<vtkm::Id>(expectedDiff.size()),
"Field sizes wrong");

2
vtkm/filter/testing/UnitTestImageMedianFilter.cxx
View File

@ -29,7 +29,7 @@ void TestImageMedian()
VTKM_TEST_ASSERT(result.HasPointField("median"), "Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetPointField("median").GetData().CopyTo(resultArrayHandle);
result.GetPointField("median").GetData().AsArrayHandle(resultArrayHandle);
auto cells = result.GetCellSet().Cast<vtkm::cont::CellSetStructured<3>>();
auto pdims = cells.GetPointDimensions();

4
vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx
View File

@ -343,7 +343,7 @@ void Test2DLCS()
vtkm::cont::DataSet outputData = lagrangianStructures.Execute(inputData);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> FTLEField;
outputData.GetField("FTLE").GetData().CopyTo(FTLEField);
outputData.GetField("FTLE").GetData().AsArrayHandle(FTLEField);
auxiliary::ValidateLCSFilterResult(FTLEField, visitHandle, diffHandle);
}
@ -387,7 +387,7 @@ void Test3DLCS()
vtkm::cont::DataSet outputData = lagrangianStructures.Execute(input);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> FTLEField;
outputData.GetField("FTLE").GetData().CopyTo(FTLEField);
outputData.GetField("FTLE").GetData().AsArrayHandle(FTLEField);
auxiliary::ValidateLCSFilterResult(FTLEField, visitHandle, diffHandle);
}
}

2
vtkm/filter/testing/UnitTestMapFieldMergeAverage.cxx
View File

@ -94,7 +94,7 @@ void TryArray(const vtkm::cont::ArrayHandle<T, S>& inputArray)
VTKM_TEST_ASSERT(outputField.GetName() == "my-array");
vtkm::cont::ArrayHandle<T> outputArray;
outputField.GetData().CopyTo(outputArray);
outputField.GetData().AsArrayHandle(outputArray);
std::cout << "Actual output" << std::endl;
vtkm::cont::printSummary_ArrayHandle(outputArray, std::cout);

2
vtkm/filter/testing/UnitTestMapFieldPermutation.cxx
View File

@ -57,7 +57,7 @@ void TryArray(const vtkm::cont::ArrayHandle<T, S>& inputArray)
VTKM_TEST_ASSERT(outputField.GetName() == "my-array");
vtkm::cont::ArrayHandle<T> outputArray;
outputField.GetData().CopyTo(outputArray);
outputField.GetData().AsArrayHandle(outputArray);
std::cout << "Actual output" << std::endl;
vtkm::cont::printSummary_ArrayHandle(outputArray, std::cout);

6
vtkm/filter/testing/UnitTestMaskFilter.cxx
View File

@ -37,7 +37,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 8 &&
cellFieldArray.ReadPortal().Get(7) == 14.f,
@ -58,7 +58,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 7), "Wrong result for Mask");
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 7 &&
cellFieldArray.ReadPortal().Get(2) == 18.f,
@ -79,7 +79,7 @@ public:
VTKM_TEST_ASSERT(test_equal(output.GetNumberOfCells(), 2), "Wrong result for Mask");
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
cellFieldArray.ReadPortal().Get(1) == 120.2f,

2
vtkm/filter/testing/UnitTestMeshQualityFilter.cxx
View File

@ -123,7 +123,7 @@ bool TestMeshQualityFilter(const vtkm::cont::DataSet& input,
//Test the computed metric values (for all cells) and expected metric
//values for equality.
vtkm::cont::ArrayHandle<vtkm::Float64> values;
output.GetField(outputname).GetData().CopyTo(values);
output.GetField(outputname).GetData().AsArrayHandle(values);
auto portal1 = values.ReadPortal();
if (portal1.GetNumberOfValues() != (vtkm::Id)expectedVals.size())
{

2
vtkm/filter/testing/UnitTestNDEntropyFilter.cxx
View File

@ -189,7 +189,7 @@ void RunTest()
vtkm::cont::DataSet outputData = ndEntropyFilter.Execute(ds);
vtkm::cont::ArrayHandle<vtkm::Float64> entropyHandle;
outputData.GetField("Entropy").GetData().CopyTo(entropyHandle);
outputData.GetField("Entropy").GetData().AsArrayHandle(entropyHandle);
vtkm::Float64 e = entropyHandle.WritePortal().Get(0);
VTKM_TEST_ASSERT(fabs(e - 7.457857) < 0.001,

8
vtkm/filter/testing/UnitTestNDHistogramFilter.cxx
View File

@ -95,13 +95,13 @@ void RunTest()
VTKM_TEST_ASSERT(nonSparseBins == gtNonSparseBins, "Incorrect ND-histogram Filter results");
vtkm::cont::ArrayHandle<vtkm::Id> binId0;
outputData.GetField("fieldA").GetData().CopyTo(binId0);
outputData.GetField("fieldA").GetData().AsArrayHandle(binId0);
vtkm::cont::ArrayHandle<vtkm::Id> binId1;
outputData.GetField("fieldB").GetData().CopyTo(binId1);
outputData.GetField("fieldB").GetData().AsArrayHandle(binId1);
vtkm::cont::ArrayHandle<vtkm::Id> binId2;
outputData.GetField("fieldC").GetData().CopyTo(binId2);
outputData.GetField("fieldC").GetData().AsArrayHandle(binId2);
vtkm::cont::ArrayHandle<vtkm::Id> freqs;
outputData.GetField("Frequency").GetData().CopyTo(freqs);
outputData.GetField("Frequency").GetData().AsArrayHandle(freqs);
for (int i = 0; i < nonSparseBins; i++)
{
vtkm::Id idx0 = binId0.WritePortal().Get(i);

4
vtkm/filter/testing/UnitTestPartitionedDataSetFilters.cxx
View File

@ -89,9 +89,9 @@ void Result_Verify(const vtkm::cont::PartitionedDataSet& result,
"result vectors' size incorrect");
vtkm::cont::ArrayHandle<T> partitionArray;
result.GetPartition(j).GetField(outputFieldName).GetData().CopyTo(partitionArray);
result.GetPartition(j).GetField(outputFieldName).GetData().AsArrayHandle(partitionArray);
vtkm::cont::ArrayHandle<T> sDataSetArray;
partitionResult.GetField(outputFieldName).GetData().CopyTo(sDataSetArray);
partitionResult.GetField(outputFieldName).GetData().AsArrayHandle(sDataSetArray);
const vtkm::Id numValues = result.GetPartition(j).GetField(outputFieldName).GetNumberOfValues();
for (vtkm::Id i = 0; i < numValues; i++)

2
vtkm/filter/testing/UnitTestPartitionedDataSetHistogramFilter.cxx
View File

@ -110,7 +110,7 @@ static void TestPartitionedDataSetHistogram()
auto bins = result.GetPartition(0)
.GetField("histogram")
.GetData()
.Cast<vtkm::cont::ArrayHandle<vtkm::Id>>();
.AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Id>>();
VTKM_TEST_ASSERT(bins.GetNumberOfValues() == 10, "Expecting 10 bins.");
auto binsPortal = bins.ReadPortal();
auto count = std::accumulate(vtkm::cont::ArrayPortalToIteratorBegin(binsPortal),

8
vtkm/filter/testing/UnitTestPointAverageFilter.cxx
View File

@ -29,7 +29,7 @@ void TestPointAverageUniform3D()
VTKM_TEST_ASSERT(result.HasPointField("avgvals"), "Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetPointField("avgvals").GetData().CopyTo(resultArrayHandle);
result.GetPointField("avgvals").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[18] = { 100.1f, 100.15f, 100.2f, 100.1f, 100.15f, 100.2f,
100.2f, 100.25f, 100.3f, 100.2f, 100.25f, 100.3f,
100.3f, 100.35f, 100.4f, 100.3f, 100.35f, 100.4f };
@ -55,7 +55,7 @@ void TestPointAverageRegular3D()
VTKM_TEST_ASSERT(result.HasPointField("cellvar"), "Field missing.");
vtkm::cont::Field Result = result.GetPointField("cellvar");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
Result.GetData().CopyTo(resultArrayHandle);
Result.GetData().AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[18] = { 0.f, 0.5f, 1.f, 0.f, 0.5f, 1.f, 1.f, 1.5f, 2.f,
1.f, 1.5f, 2.f, 2.f, 2.5f, 3.f, 2.f, 2.5f, 3.f };
@ -80,7 +80,7 @@ void TestPointAverageExplicit1()
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasPointField("cellvar"), "Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetPointField("cellvar").GetData().CopyTo(resultArrayHandle);
result.GetPointField("cellvar").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[5] = { 100.1f, 100.15f, 100.15f, 100.2f, 100.2f };
for (int i = 0; i < 5; ++i)
{
@ -103,7 +103,7 @@ void TestPointAverageExplicit2()
// If no name is given, should have the same name as the input.
VTKM_TEST_ASSERT(result.HasPointField("cellvar"), "Field missing.");
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
result.GetPointField("cellvar").GetData().CopyTo(resultArrayHandle);
result.GetPointField("cellvar").GetData().AsArrayHandle(resultArrayHandle);
vtkm::Float32 expected[11] = { 100.1f, 105.05f, 105.05f, 100.1f, 115.3f, 115.2f,
115.2f, 115.3f, 115.1f, 130.5f, 125.35f };
for (int i = 0; i < 11; ++i)

4
vtkm/filter/testing/UnitTestPointElevationFilter.cxx
View File

@ -75,7 +75,7 @@ void TestPointElevationNoPolicy()
VTKM_TEST_ASSERT(result.HasPointField("height"), "Output field missing.");
vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
result.GetPointField("height").GetData().CopyTo(resultArrayHandle);
result.GetPointField("height").GetData().AsArrayHandle(resultArrayHandle);
auto coordinates = inputData.GetCoordinateSystem().GetDataAsMultiplexer();
auto coordsPortal = coordinates.ReadPortal();
auto resultPortal = resultArrayHandle.ReadPortal();
@ -106,7 +106,7 @@ void TestPointElevationWithPolicy()
VTKM_TEST_ASSERT(result.HasPointField("elevation"), "Output field has wrong association");
vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
result.GetPointField("elevation").GetData().CopyTo(resultArrayHandle);
result.GetPointField("elevation").GetData().AsArrayHandle(resultArrayHandle);
auto coordinates = inputData.GetCoordinateSystem().GetDataAsMultiplexer();
auto coordsPortal = coordinates.ReadPortal();
auto resultPortal = resultArrayHandle.ReadPortal();

2
vtkm/filter/testing/UnitTestPointTransform.cxx
View File

@ -72,7 +72,7 @@ void ValidatePointTransform(const vtkm::cont::CoordinateSystem& coords,
vtkm::cont::ArrayHandle<vtkm::Vec3f> resultArrayHandle;
result.GetField(fieldName, vtkm::cont::Field::Association::POINTS)
.GetData()
.CopyTo(resultArrayHandle);
.AsArrayHandle(resultArrayHandle);
auto outPointsArrayHandle = result.GetCoordinateSystem().GetDataAsMultiplexer();

4
vtkm/filter/testing/UnitTestSplitSharpEdgesFilter.cxx
View File

@ -134,7 +134,7 @@ void TestSplitSharpEdgesFilterSplitEveryEdge(vtkm::cont::DataSet& simpleCubeWith
auto newCoords = result.GetCoordinateSystem().GetDataAsMultiplexer();
auto newCoordsP = newCoords.ReadPortal();
vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointvarField;
result.GetField("pointvar").GetData().CopyTo(newPointvarField);
result.GetField("pointvar").GetData().AsArrayHandle(newPointvarField);
for (vtkm::IdComponent i = 0; i < newCoords.GetNumberOfValues(); i++)
{
@ -169,7 +169,7 @@ void TestSplitSharpEdgesFilterNoSplit(vtkm::cont::DataSet& simpleCubeWithSN,
result.GetCellSet().Cast<vtkm::cont::CellSetExplicit<>>();
auto newCoordsP = newCoords.ReadPortal();
vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointvarField;
result.GetField("pointvar").GetData().CopyTo(newPointvarField);
result.GetField("pointvar").GetData().AsArrayHandle(newPointvarField);
for (vtkm::IdComponent i = 0; i < newCoords.GetNumberOfValues(); i++)
{

4
vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx
View File

@ -18,7 +18,7 @@ namespace
void VerifyCellNormalValues(const vtkm::cont::DataSet& ds)
{
vtkm::cont::ArrayHandle<vtkm::Vec3f> normals;
ds.GetCellField("Normals").GetData().CopyTo(normals);
ds.GetCellField("Normals").GetData().AsArrayHandle(normals);
vtkm::Vec3f expected[8] = { { -0.707f, -0.500f, 0.500f }, { -0.707f, -0.500f, 0.500f },
{ 0.707f, 0.500f, -0.500f }, { 0.000f, -0.707f, -0.707f },
@ -37,7 +37,7 @@ void VerifyCellNormalValues(const vtkm::cont::DataSet& ds)
void VerifyPointNormalValues(const vtkm::cont::DataSet& ds)
{
vtkm::cont::ArrayHandle<vtkm::Vec3f> normals;
ds.GetPointField("Normals").GetData().CopyTo(normals);
ds.GetPointField("Normals").GetData().AsArrayHandle(normals);
vtkm::Vec3f expected[8] = { { -0.8165f, -0.4082f, -0.4082f }, { -0.2357f, -0.9714f, 0.0286f },
{ 0.0000f, -0.1691f, 0.9856f }, { -0.8660f, 0.0846f, 0.4928f },

4
vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx
View File

@ -35,7 +35,7 @@ public:
"Wrong number of points for Tetrahedralize");
vtkm::cont::ArrayHandle<vtkm::Float32> outData =
output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
VTKM_TEST_ASSERT(outData.ReadPortal().Get(5) == 100.2f, "Wrong cell field data");
VTKM_TEST_ASSERT(outData.ReadPortal().Get(6) == 100.2f, "Wrong cell field data");
@ -58,7 +58,7 @@ public:
"Wrong number of points for Tetrahedralize");
vtkm::cont::ArrayHandle<vtkm::Float32> outData =
output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
VTKM_TEST_ASSERT(outData.ReadPortal().Get(5) == 110.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outData.ReadPortal().Get(6) == 110.f, "Wrong cell field data");

8
vtkm/filter/testing/UnitTestThresholdFilter.cxx
View File

@ -39,7 +39,7 @@ public:
"Wrong number of fields in the output dataset");
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 1 &&
cellFieldArray.ReadPortal().Get(0) == 200.1f,
@ -68,7 +68,7 @@ public:
"Wrong number of fields in the output dataset");
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
cellFieldArray.ReadPortal().Get(0) == 100.1f &&
@ -98,7 +98,7 @@ public:
"Wrong number of fields in the output dataset");
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
cellFieldArray.ReadPortal().Get(0) == 100.1f &&
@ -128,7 +128,7 @@ public:
"Wrong number of fields in the output dataset");
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray;
output.GetField("cellvar").GetData().CopyTo(cellFieldArray);
output.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 0, "field should be empty");

6
vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx
View File

@ -38,7 +38,7 @@ public:
vtkm::cont::Field pointField = output.GetField("pointvar");
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
pointField.GetData().CopyTo(pointFieldArray);
pointField.GetData().AsArrayHandle(pointFieldArray);
VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(12) == 50.0f, "Wrong point field data");
}
@ -60,7 +60,7 @@ public:
vtkm::cont::Field pointField = output.GetField("pointvar");
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
pointField.GetData().CopyTo(pointFieldArray);
pointField.GetData().AsArrayHandle(pointFieldArray);
VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(0) == 99.0f, "Wrong point field data");
}
@ -82,7 +82,7 @@ public:
vtkm::cont::Field pointField = output.GetField("pointvar");
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
pointField.GetData().CopyTo(pointFieldArray);
pointField.GetData().AsArrayHandle(pointFieldArray);
VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(4) == 10.f, "Wrong point field data");
}

4
vtkm/filter/testing/UnitTestTriangulateFilter.cxx
View File

@ -33,7 +33,7 @@ public:
"Wrong number of points for Triangulate");
vtkm::cont::ArrayHandle<vtkm::Float32> outData =
output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
VTKM_TEST_ASSERT(outData.ReadPortal().Get(2) == 1.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outData.ReadPortal().Get(3) == 1.f, "Wrong cell field data");
@ -53,7 +53,7 @@ public:
"Wrong number of points for Triangulate");
vtkm::cont::ArrayHandle<vtkm::Float32> outData =
output.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
output.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
VTKM_TEST_ASSERT(outData.ReadPortal().Get(1) == 1.f, "Wrong cell field data");
VTKM_TEST_ASSERT(outData.ReadPortal().Get(2) == 1.f, "Wrong cell field data");

8
vtkm/filter/testing/UnitTestTubeFilter.cxx
View File

@ -82,8 +82,8 @@ void TestTubeFilters()
VTKM_TEST_ASSERT(dcells.GetNumberOfCells() == 36, "Wrong number of cells");
//Validate the point field
auto ptArr =
output.GetField("pointVar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>();
vtkm::cont::ArrayHandle<vtkm::FloatDefault> ptArr;
output.GetField("pointVar").GetData().AsArrayHandle(ptArr);
VTKM_TEST_ASSERT(ptArr.GetNumberOfValues() == 22, "Wrong number of values in point field");
std::vector<vtkm::FloatDefault> ptVals = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 2,
@ -95,8 +95,8 @@ void TestTubeFilters()
//Validate the cell field
auto cellArr =
output.GetField("cellVar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::FloatDefault>>();
vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellArr;
output.GetField("cellVar").GetData().AsArrayHandle(cellArr);
VTKM_TEST_ASSERT(cellArr.GetNumberOfValues() == 36, "Wrong number of values in cell field");
std::vector<vtkm::FloatDefault> cellVals = { 100, 100, 100, 100, 100, 100, 101, 101, 101,
101, 101, 101, 100, 100, 100, 101, 101, 101,

2
vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx
View File

@ -45,7 +45,7 @@ void TestVectorMagnitude()
VTKM_TEST_ASSERT(result.HasPointField("magnitude"), "Output field missing.");
vtkm::cont::ArrayHandle<vtkm::Float64> resultArrayHandle;
result.GetPointField("magnitude").GetData().CopyTo(resultArrayHandle);
result.GetPointField("magnitude").GetData().AsArrayHandle(resultArrayHandle);
for (vtkm::Id i = 0; i < resultArrayHandle.GetNumberOfValues(); ++i)
{
VTKM_TEST_ASSERT(

5
vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx
View File

@ -33,8 +33,9 @@ void TestVertexClustering()
"Number of output coordinate systems mismatch");
using FieldArrayType = vtkm::cont::ArrayHandle<vtkm::Float32>;
FieldArrayType pointvar = output.GetPointField("pointvar").GetData().Cast<FieldArrayType>();
FieldArrayType cellvar = output.GetCellField("cellvar").GetData().Cast<FieldArrayType>();
FieldArrayType pointvar =
output.GetPointField("pointvar").GetData().AsArrayHandle<FieldArrayType>();
FieldArrayType cellvar = output.GetCellField("cellvar").GetData().AsArrayHandle<FieldArrayType>();
// test
const vtkm::Id output_points = 7;

4
vtkm/filter/testing/UnitTestWarpScalarFilter.cxx
View File

@ -59,11 +59,11 @@ void CheckResult(const vtkm::filter::WarpScalar& filter, const vtkm::cont::DataS
VTKM_TEST_ASSERT(result.HasPointField("warpscalar"), "Output filed warpscalar is missing");
using vecType = vtkm::Vec3f;
vtkm::cont::ArrayHandle<vecType> outputArray;
result.GetPointField("warpscalar").GetData().CopyTo(outputArray);
result.GetPointField("warpscalar").GetData().AsArrayHandle(outputArray);
auto outPortal = outputArray.ReadPortal();
vtkm::cont::ArrayHandle<vtkm::FloatDefault> sfArray;
result.GetPointField("scalarfactor").GetData().CopyTo(sfArray);
result.GetPointField("scalarfactor").GetData().AsArrayHandle(sfArray);
auto sfPortal = sfArray.ReadPortal();
for (vtkm::Id j = 0; j < dim; ++j)

2
vtkm/filter/testing/UnitTestWarpVectorFilter.cxx
View File

@ -56,7 +56,7 @@ void CheckResult(const vtkm::filter::WarpVector& filter, const vtkm::cont::DataS
VTKM_TEST_ASSERT(result.HasPointField("warpvector"), "Output filed WarpVector is missing");
using vecType = vtkm::Vec3f;
vtkm::cont::ArrayHandle<vecType> outputArray;
result.GetPointField("warpvector").GetData().CopyTo(outputArray);
result.GetPointField("warpvector").GetData().AsArrayHandle(outputArray);
auto outPortal = outputArray.ReadPortal();
for (vtkm::Id j = 0; j < dim; ++j)

18
vtkm/filter/testing/UnitTestZFP.cxx
View File

@ -30,8 +30,8 @@ void TestZFP1DFilter(vtkm::Float64 rate)
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataset = testDataSet.Make1DUniformDataSet2();
auto dynField = dataset.GetField("pointvar").GetData();
vtkm::cont::ArrayHandle<vtkm::Float64> field =
dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
vtkm::cont::ArrayHandle<vtkm::Float64> field;
dynField.AsArrayHandle(field);
auto oport = field.ReadPortal();
vtkm::filter::ZFPCompressor1D compressor;
@ -46,7 +46,7 @@ void TestZFP1DFilter(vtkm::Float64 rate)
auto decompress = decompressor.Execute(compressed);
dynField = decompress.GetField("decompressed").GetData();
field = dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
dynField.AsArrayHandle(field);
auto port = field.ReadPortal();
for (int i = 0; i < field.GetNumberOfValues(); i++)
@ -61,8 +61,8 @@ void TestZFP2DFilter(vtkm::Float64 rate)
vtkm::cont::DataSet dataset = testDataSet.Make2DUniformDataSet2();
auto dynField = dataset.GetField("pointvar").GetData();
vtkm::cont::ArrayHandle<vtkm::Float64> field =
dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
vtkm::cont::ArrayHandle<vtkm::Float64> field;
dynField.AsArrayHandle(field);
auto oport = field.ReadPortal();
@ -80,7 +80,7 @@ void TestZFP2DFilter(vtkm::Float64 rate)
auto decompress = decompressor.Execute(compressed);
dynField = decompress.GetField("decompressed").GetData();
field = dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
dynField.AsArrayHandle(field);
auto port = field.ReadPortal();
for (int i = 0; i < dynField.GetNumberOfValues(); i++)
@ -95,8 +95,8 @@ void TestZFP3DFilter(vtkm::Float64 rate)
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataset = testDataSet.Make3DUniformDataSet3(dims);
auto dynField = dataset.GetField("pointvar").GetData();
vtkm::cont::ArrayHandle<vtkm::Float64> field =
dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
vtkm::cont::ArrayHandle<vtkm::Float64> field;
dynField.AsArrayHandle(field);
auto oport = field.ReadPortal();
@ -112,7 +112,7 @@ void TestZFP3DFilter(vtkm::Float64 rate)
auto decompress = decompressor.Execute(compressed);
dynField = decompress.GetField("decompressed").GetData();
field = dynField.Cast<vtkm::cont::ArrayHandle<vtkm::Float64>>();
dynField.AsArrayHandle(field);
auto port = field.ReadPortal();
for (int i = 0; i < dynField.GetNumberOfValues(); i++)

2
vtkm/io/ImageWriterBase.cxx
View File

@ -75,7 +75,7 @@ void ImageWriterBase::WriteDataSet(const vtkm::cont::DataSet& dataSet,
}
}
this->Write(width, height, colorField.GetData().Cast<ColorArrayType>());
this->Write(width, height, colorField.GetData().AsArrayHandle<ColorArrayType>());
}
}
} // namespace vtkm::io

6
vtkm/io/VTKDataSetWriter.cxx
View File

@ -337,17 +337,17 @@ void WriteDataSetAsStructured(std::ostream& out,
{
// uniform is written as "structured points"
WriteDataSetAsStructuredPoints(
out, coordSystem.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>(), cellSet);
out, coordSystem.AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>(), cellSet);
}
else if (coordSystem.IsType<ArrayHandleRectilinearCoordinates<vtkm::Float32>>())
{
WriteDataSetAsRectilinearGrid(
out, coordSystem.Cast<ArrayHandleRectilinearCoordinates<vtkm::Float32>>(), cellSet);
out, coordSystem.AsArrayHandle<ArrayHandleRectilinearCoordinates<vtkm::Float32>>(), cellSet);
}
else if (coordSystem.IsType<ArrayHandleRectilinearCoordinates<vtkm::Float64>>())
{
WriteDataSetAsRectilinearGrid(
out, coordSystem.Cast<ArrayHandleRectilinearCoordinates<vtkm::Float64>>(), cellSet);
out, coordSystem.AsArrayHandle<ArrayHandleRectilinearCoordinates<vtkm::Float64>>(), cellSet);
}
else
{

5
vtkm/io/testing/UnitTestHDF5Image.cxx
View File

@ -32,8 +32,9 @@ void TestFilledImage(vtkm::cont::DataSet& dataSet,
"wrong image dimensions");
VTKM_TEST_ASSERT(pointField.GetData().template IsType<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>(),
"wrong ArrayHandle type");
auto pixelPortal =
pointField.GetData().template Cast<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>().ReadPortal();
vtkm::cont::ArrayHandle<vtkm::Vec4f_32> pixelArray;
pointField.GetData().AsArrayHandle(pixelArray);
auto pixelPortal = pixelArray.ReadPortal();
auto colorPortal = canvas.GetColorBuffer().ReadPortal();

5
vtkm/io/testing/UnitTestImageWriter.cxx
View File

@ -36,8 +36,9 @@ void TestFilledImage(vtkm::cont::DataSet& dataSet,
"wrong image dimensions");
VTKM_TEST_ASSERT(pointField.GetData().template IsType<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>(),
"wrong ArrayHandle type");
auto pixelPortal =
pointField.GetData().template Cast<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>().ReadPortal();
auto pixelPortal = pointField.GetData()
.template AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Vec4f_32>>()
.ReadPortal();
auto colorPortal = canvas.GetColorBuffer().ReadPortal();

6
vtkm/io/testing/UnitTestVTKDataSetWriter.cxx
View File

@ -30,7 +30,7 @@ struct CheckSameField
const vtkm::cont::Field& fileField) const
{
vtkm::cont::ArrayHandle<T> fileArray;
fileField.GetData().CopyTo(fileArray);
fileField.GetData().AsArrayHandle(fileArray);
VTKM_TEST_ASSERT(test_equal_portals(originalArray.ReadPortal(), fileArray.ReadPortal()));
}
};
@ -67,7 +67,7 @@ struct CheckSameCoordinateSystem
{
VTKM_TEST_ASSERT(fileCoords.GetData().IsType<vtkm::cont::ArrayHandleUniformPointCoordinates>());
vtkm::cont::ArrayHandleUniformPointCoordinates fileArray =
fileCoords.GetData().Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
fileCoords.GetData().AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>();
auto originalPortal = originalArray.ReadPortal();
auto filePortal = fileArray.ReadPortal();
VTKM_TEST_ASSERT(test_equal(originalPortal.GetOrigin(), filePortal.GetOrigin()));
@ -87,7 +87,7 @@ struct CheckSameCoordinateSystem
{
VTKM_TEST_ASSERT(fileCoords.GetData().IsType<ArrayHandleRectilinearCoords<T>>());
ArrayHandleRectilinearCoords<T> fileArray =
fileCoords.GetData().Cast<ArrayHandleRectilinearCoords<T>>();
fileCoords.GetData().AsArrayHandle<ArrayHandleRectilinearCoords<T>>();
auto originalPortal = originalArray.ReadPortal();
auto filePortal = fileArray.ReadPortal();
VTKM_TEST_ASSERT(

4
vtkm/source/testing/UnitTestTangleSource.cxx
View File

@ -44,7 +44,7 @@ void TangleSourceTest()
auto field = ds.GetCellField("cellvar");
auto dynData = field.GetData();
VTKM_TEST_ASSERT(dynData.IsType<ScalarHandleType>(), "Invalid scalar handle type.");
ScalarHandleType handle = dynData.Cast<ScalarHandleType>();
ScalarHandleType handle = dynData.AsArrayHandle<ScalarHandleType>();
auto data = handle.ReadPortal();
VTKM_TEST_ASSERT(test_equal(data.GetNumberOfValues(), 8000), "Incorrect number of elements.");
@ -62,7 +62,7 @@ void TangleSourceTest()
auto field = ds.GetPointField("nodevar");
auto dynData = field.GetData();
VTKM_TEST_ASSERT(dynData.IsType<ScalarHandleType>(), "Invalid scalar handle type.");
ScalarHandleType handle = dynData.Cast<ScalarHandleType>();
ScalarHandleType handle = dynData.AsArrayHandle<ScalarHandleType>();
auto data = handle.ReadPortal();
VTKM_TEST_ASSERT(test_equal(data.GetNumberOfValues(), 9261), "Incorrect number of scalars.");

2
vtkm/source/testing/UnitTestWaveletSource.cxx
View File

@ -44,7 +44,7 @@ void WaveletSourceTest()
auto field = ds.GetPointField("scalars");
auto dynData = field.GetData();
VTKM_TEST_ASSERT(dynData.IsType<ScalarHandleType>(), "Invalid scalar handle type.");
ScalarHandleType handle = dynData.Cast<ScalarHandleType>();
ScalarHandleType handle = dynData.AsArrayHandle<ScalarHandleType>();
auto data = handle.ReadPortal();
VTKM_TEST_ASSERT(test_equal(data.GetNumberOfValues(), 9261), "Incorrect number of scalars.");

4
vtkm/worklet/ExternalFaces.h
View File

@ -712,7 +712,7 @@ public:
auto coordData = coord.GetData();
if (coordData.IsType<CartesianArrayHandle>())
{
const auto vertices = coordData.Cast<CartesianArrayHandle>();
const auto vertices = coordData.AsArrayHandle<CartesianArrayHandle>();
const auto vertsSize = vertices.GetNumberOfValues();
const auto tmp = vtkm::cont::ArrayGetValues({ 0, vertsSize - 1 }, vertices);
MinPoint = tmp[0];
@ -720,7 +720,7 @@ public:
}
else
{
auto vertices = coordData.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
auto vertices = coordData.AsArrayHandle<vtkm::cont::ArrayHandleUniformPointCoordinates>();
auto Coordinates = vertices.ReadPortal();
MinPoint = Coordinates.GetOrigin();

4
vtkm/worklet/NDimsHistogram.h
View File

@ -58,8 +58,8 @@ public:
}
else
{
CastAndCall(
fieldArray.ResetTypes(vtkm::TypeListScalarAll()),
vtkm::cont::CastAndCall(
fieldArray.ResetTypes(vtkm::TypeListScalarAll{}, VTKM_DEFAULT_STORAGE_LIST{}),
vtkm::worklet::histogram::ComputeBins(Bin1DIndex, numberOfBins, rangeOfValues, binDelta));
}
}

2
vtkm/worklet/PointMerge.h
View File

@ -430,7 +430,7 @@ public:
vtkm::cont::ArrayHandle<vtkm::Vec3f> concretePoints;
if (points.template IsType<decltype(concretePoints)>())
{
concretePoints = points.template Cast<decltype(concretePoints)>();
points.AsArrayHandle(concretePoints);
}
else
{

2
vtkm/worklet/StreamLineUniformGrid.h
View File

@ -331,7 +331,7 @@ public:
vtkm::Id3 vdims = inCellSet.GetSchedulingRange(vtkm::TopologyElementTagPoint());
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> fieldArray;
InDataSet.GetField("vecData").GetData().CopyTo(fieldArray);
InDataSet.GetField("vecData").GetData().AsArrayHandle(fieldArray);
// Generate random seeds for starting streamlines
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray;

2
vtkm/worklet/StreamSurface.h
View File

@ -257,7 +257,7 @@ public:
vtkm::cont::Algorithm::ScanExclusive(triangleConnCount, triangleConnOffset);
//Surface points are same as input points.
newPoints = coords.GetData().Cast<ExplCoordsType>();
newPoints = coords.GetData().AsArrayHandle<ExplCoordsType>();
//Create surface triangles
vtkm::Id numConnIds = vtkm::cont::Algorithm::Reduce(triangleConnCount, vtkm::Id(0));

15
vtkm/worklet/contourtree_distributed/TreeCompiler.h
View File

@ -232,27 +232,32 @@ inline void TreeCompiler::AddHierarchicalTree(const vtkm::cont::DataSet& addedTr
std::vector<vtkm::Id> regularNodeGlobalIds(regularNodeGlobalIds_array.GetNumberOfValues());
auto regularNodeGlobalIds_handle =
vtkm::cont::make_ArrayHandle(regularNodeGlobalIds, vtkm::CopyFlag::Off);
vtkm::cont::ArrayCopy(regularNodeGlobalIds_array.ResetTypes(vtkm::List<vtkm::Id>{}),
regularNodeGlobalIds_handle);
vtkm::cont::ArrayCopy(
regularNodeGlobalIds_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
regularNodeGlobalIds_handle);
regularNodeGlobalIds_handle
.SyncControlArray(); //Forces values to get updated if copy happened on GPU
auto superarcs_array = addedTree.GetField("Superarcs").GetData();
std::vector<vtkm::Id> added_tree_superarcs(superarcs_array.GetNumberOfValues());
auto superarcs_handle = vtkm::cont::make_ArrayHandle(added_tree_superarcs, vtkm::CopyFlag::Off);
vtkm::cont::ArrayCopy(superarcs_array.ResetTypes(vtkm::List<vtkm::Id>{}), superarcs_handle);
vtkm::cont::ArrayCopy(superarcs_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
superarcs_handle);
superarcs_handle.SyncControlArray(); //Forces values to get updated if copy happened on GPU
auto supernodes_array = addedTree.GetField("Supernodes").GetData();
std::vector<vtkm::Id> added_tree_supernodes(supernodes_array.GetNumberOfValues());
auto supernodes_handle = vtkm::cont::make_ArrayHandle(added_tree_supernodes, vtkm::CopyFlag::Off);
vtkm::cont::ArrayCopy(supernodes_array.ResetTypes(vtkm::List<vtkm::Id>{}), supernodes_handle);
vtkm::cont::ArrayCopy(supernodes_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
supernodes_handle);
supernodes_handle.SyncControlArray(); //Forces values to get updated if copy happened on GPU
auto superparents_array = addedTree.GetField("Superparents").GetData();
std::vector<vtkm::Id> superparents(superparents_array.GetNumberOfValues());
auto superparents_handle = vtkm::cont::make_ArrayHandle(superparents, vtkm::CopyFlag::Off);
vtkm::cont::ArrayCopy(superparents_array.ResetTypes(vtkm::List<vtkm::Id>{}), superparents_handle);
vtkm::cont::ArrayCopy(
superparents_array.ResetTypes<vtkm::TypeListId, VTKM_DEFAULT_STORAGE_LIST>(),
superparents_handle);
superparents_handle.SyncControlArray(); //Forces values to get updated if copy happened on GPU
// loop through all of the supernodes in the hierarchical tree

2
vtkm/worklet/particleadvection/GridEvaluators.h
View File

@ -181,7 +181,7 @@ public:
{
auto arr = dataSet.GetCellField("vtkmGhostCells").GetData();
if (arr.IsType<GhostCellArrayType>())
this->GhostCellArray = arr.Cast<GhostCellArrayType>();
this->GhostCellArray = arr.AsArrayHandle<GhostCellArrayType>();
else
throw vtkm::cont::ErrorInternal("vtkmGhostCells not of type vtkm::UInt8");
}

6
vtkm/worklet/testing/UnitTestCellGradient.cxx
View File

@ -26,7 +26,7 @@ void TestCellGradientUniform2D()
vtkm::cont::ArrayHandle<vtkm::Float32> input;
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> result;
dataSet.GetField("pointvar").GetData().CopyTo(input);
dataSet.GetField("pointvar").GetData().AsArrayHandle(input);
vtkm::worklet::CellGradient gradient;
result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);
@ -49,7 +49,7 @@ void TestCellGradientUniform3D()
vtkm::cont::ArrayHandle<vtkm::Float32> input;
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> result;
dataSet.GetField("pointvar").GetData().CopyTo(input);
dataSet.GetField("pointvar").GetData().AsArrayHandle(input);
vtkm::worklet::CellGradient gradient;
result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);
@ -218,7 +218,7 @@ void TestCellGradientExplicit()
vtkm::cont::ArrayHandle<vtkm::Float32> input;
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> result;
dataSet.GetField("pointvar").GetData().CopyTo(input);
dataSet.GetField("pointvar").GetData().AsArrayHandle(input);
vtkm::worklet::CellGradient gradient;
result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);

22
vtkm/worklet/testing/UnitTestClipping.cxx
View File

@ -116,7 +116,8 @@ void TestClippingExplicit()
bool invertClip = false;
vtkm::cont::CellSetExplicit<> outputCellSet =
clip.Run(ds.GetCellSet(),
ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar{},
VTKM_DEFAULT_STORAGE_LIST{}),
clipValue,
invertClip);
@ -124,11 +125,11 @@ void TestClippingExplicit()
vtkm::cont::ArrayHandle<Coord3D> coords = clip.ProcessPointField(coordsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
ds.GetField("scalars").GetData().CopyTo(scalarsIn);
ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
vtkm::Id connectivitySize = 8;
@ -172,7 +173,8 @@ void TestClippingStructured()
vtkm::worklet::Clip clip;
vtkm::cont::CellSetExplicit<> outputCellSet =
clip.Run(ds.GetCellSet(),
ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
ds.GetField("scalars").GetData().ResetTypes(vtkm::TypeListFieldScalar{},
VTKM_DEFAULT_STORAGE_LIST{}),
clipValue,
invertClip);
@ -180,11 +182,11 @@ void TestClippingStructured()
CoordsOutType coords = clip.ProcessPointField(coordsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
ds.GetField("scalars").GetData().CopyTo(scalarsIn);
ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
@ -242,11 +244,11 @@ void TestClippingWithImplicitFunction()
vtkm::cont::ArrayHandle<Coord3D> coords = clip.ProcessPointField(coordsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
ds.GetField("scalars").GetData().CopyTo(scalarsIn);
ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
vtkm::Id connectivitySize = 28;
@ -301,11 +303,11 @@ void TestClippingWithImplicitFunctionInverted()
vtkm::cont::ArrayHandle<Coord3D> coords = clip.ProcessPointField(coordsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalarsIn;
ds.GetField("scalars").GetData().CopyTo(scalarsIn);
ds.GetField("scalars").GetData().AsArrayHandle(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> scalars = clip.ProcessPointField(scalarsIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvarIn;
ds.GetField("cellvar").GetData().CopyTo(cellvarIn);
ds.GetField("cellvar").GetData().AsArrayHandle(cellvarIn);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar = clip.ProcessCellField(cellvarIn);
vtkm::Id connectivitySize = 12;

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

@ -192,9 +192,9 @@ void TestContourUniformGrid()
vtkm::cont::CellSetStructured<3> cellSet;
dataSet.GetCellSet().CopyTo(cellSet);
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
dataSet.GetField("nodevar").GetData().CopyTo(pointFieldArray);
dataSet.GetField("nodevar").GetData().AsArrayHandle(pointFieldArray);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArray;
dataSet.GetField("cellvar").GetData().CopyTo(cellFieldArray);
dataSet.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
vtkm::worklet::Contour contour;
contour.SetMergeDuplicatePoints(false);
@ -311,7 +311,7 @@ void TestContourExplicit()
vtkm::cont::Field contourField = dataSet.GetField("distanceToOrigin");
DataSetGenerator::DataArrayHandle contourArray;
contourField.GetData().CopyTo(contourArray);
contourField.GetData().AsArrayHandle(contourArray);
Vec3Handle vertices;
Vec3Handle normals;
@ -326,12 +326,12 @@ void TestContourExplicit()
vtkm::cont::Field projectedField = dataSet.GetField("distanceToOther");
DataSetGenerator::DataArrayHandle projectedArray;
projectedField.GetData().CopyTo(projectedArray);
projectedField.GetData().AsArrayHandle(projectedArray);
scalars = Contour.ProcessPointField(projectedArray);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArray;
dataSet.GetField("cellvar").GetData().CopyTo(cellFieldArray);
dataSet.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArrayOut;
cellFieldArrayOut = Contour.ProcessCellField(cellFieldArray);
@ -372,9 +372,9 @@ void TestContourClipped()
vtkm::cont::CellSetExplicit<> cellSet;
clipped.GetCellSet().CopyTo(cellSet);
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
clipped.GetField("nodevar").GetData().CopyTo(pointFieldArray);
clipped.GetField("nodevar").GetData().AsArrayHandle(pointFieldArray);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> cellFieldArray;
clipped.GetField("cellvar").GetData().CopyTo(cellFieldArray);
clipped.GetField("cellvar").GetData().AsArrayHandle(cellFieldArray);
std::vector<vtkm::Float32> contourValue{ 0.5f };
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> verticesArray;

4
vtkm/worklet/testing/UnitTestContourTreeUniform.cxx
View File

@ -85,7 +85,7 @@ public:
vtkm::Id nCols = pointDimensions[1];
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
// Output saddle peak pairs array
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
@ -132,7 +132,7 @@ public:
vtkm::Id nSlices = pointDimensions[2];
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
// Output saddle peak pairs array
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;

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

@ -376,7 +376,7 @@ private:
vtkm::Id3 pointDimensions = cellSet.GetPointDimensions();
vtkm::cont::ArrayHandle<vtkm::Float32> field;
dataSet.GetField("pointvar").GetData().CopyTo(field);
dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
// Run the specific test
CallTestContourTreeAugmentedSteps(
@ -725,7 +725,7 @@ public:
vtkm::Id3 meshSize{ pointDimensions2D[0], pointDimensions2D[1], 1 };
vtkm::cont::ArrayHandle<vtkm::Float32> field;
dataSet.GetField("pointvar").GetData().CopyTo(field);
dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
// Create the worklet and run it
vtkm::worklet::ContourTreeAugmented contourTreeWorklet;
@ -791,7 +791,7 @@ public:
vtkm::Id3 pointDimensions = cellSet.GetPointDimensions();
vtkm::cont::ArrayHandle<vtkm::Float32> field;
dataSet.GetField("pointvar").GetData().CopyTo(field);
dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
// Create the worklet and run it
vtkm::worklet::ContourTreeAugmented contourTreeWorklet;
@ -864,7 +864,7 @@ public:
vtkm::Id3 pointDimensions = cellSet.GetPointDimensions();
vtkm::cont::ArrayHandle<vtkm::Float32> field;
dataSet.GetField("pointvar").GetData().CopyTo(field);
dataSet.GetField("pointvar").GetData().AsArrayHandle(field);
// Create the worklet and run it
vtkm::worklet::ContourTreeAugmented contourTreeWorklet;

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

@ -195,11 +195,11 @@ void TestCosmo_2DHaloFind()
vtkm::cont::ArrayHandle<vtkm::Id> haloIdArray;
vtkm::cont::ArrayHandle<vtkm::Id> mbpArray;
dataSet.GetField("xLocation").GetData().CopyTo(xLocArray);
dataSet.GetField("yLocation").GetData().CopyTo(yLocArray);
dataSet.GetField("zLocation").GetData().CopyTo(zLocArray);
dataSet.GetField("haloId").GetData().CopyTo(haloIdArray);
dataSet.GetField("mbp").GetData().CopyTo(mbpArray);
dataSet.GetField("xLocation").GetData().AsArrayHandle(xLocArray);
dataSet.GetField("yLocation").GetData().AsArrayHandle(yLocArray);
dataSet.GetField("zLocation").GetData().AsArrayHandle(zLocArray);
dataSet.GetField("haloId").GetData().AsArrayHandle(haloIdArray);
dataSet.GetField("mbp").GetData().AsArrayHandle(mbpArray);
// Output haloId, MBP, potential per particle
vtkm::cont::ArrayHandle<vtkm::Id> resultHaloId;
@ -247,11 +247,11 @@ void TestCosmo_3DHaloFind()
vtkm::cont::ArrayHandle<vtkm::Id> haloIdArray;
vtkm::cont::ArrayHandle<vtkm::Id> mbpArray;
dataSet.GetField("xLocation").GetData().CopyTo(xLocArray);
dataSet.GetField("yLocation").GetData().CopyTo(yLocArray);
dataSet.GetField("zLocation").GetData().CopyTo(zLocArray);
dataSet.GetField("haloId").GetData().CopyTo(haloIdArray);
dataSet.GetField("mbp").GetData().CopyTo(mbpArray);
dataSet.GetField("xLocation").GetData().AsArrayHandle(xLocArray);
dataSet.GetField("yLocation").GetData().AsArrayHandle(yLocArray);
dataSet.GetField("zLocation").GetData().AsArrayHandle(zLocArray);
dataSet.GetField("haloId").GetData().AsArrayHandle(haloIdArray);
dataSet.GetField("mbp").GetData().AsArrayHandle(mbpArray);
// Output haloId, MBP, potential per particle
vtkm::cont::ArrayHandle<vtkm::Id> resultHaloId;
@ -297,9 +297,9 @@ void TestCosmo_3DCenterFind()
vtkm::cont::ArrayHandle<vtkm::Float32> yLocArray;
vtkm::cont::ArrayHandle<vtkm::Float32> zLocArray;
vtkm::cont::ArrayHandle<vtkm::Id> haloIdArray;
dataSet.GetField("xLocation").GetData().CopyTo(xLocArray);
dataSet.GetField("yLocation").GetData().CopyTo(yLocArray);
dataSet.GetField("zLocation").GetData().CopyTo(zLocArray);
dataSet.GetField("xLocation").GetData().AsArrayHandle(xLocArray);
dataSet.GetField("yLocation").GetData().AsArrayHandle(yLocArray);
dataSet.GetField("zLocation").GetData().AsArrayHandle(zLocArray);
// Output haloId MBP particleId pairs array
vtkm::Pair<vtkm::Id, vtkm::Float32> nxnResult;

12
vtkm/worklet/testing/UnitTestExtractGeometry.cxx
View File

@ -40,7 +40,7 @@ public:
OutCellSetType outCellSet = extractGeometry.Run(cellSet, cellIds);
auto cellvar =
dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nCells),
@ -81,7 +81,7 @@ public:
extractOnlyBoundaryCells);
auto cellvar =
dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
@ -115,7 +115,7 @@ public:
OutCellSetType outCellSet = extractGeometry.Run(cellSet, cellIds);
auto cellvar =
dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nCells),
@ -148,7 +148,7 @@ public:
OutCellSetType outCellSet = extractGeometry.Run(cellSet, cellIds);
auto cellvar =
dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nCells),
@ -189,7 +189,7 @@ public:
extractOnlyBoundaryCells);
auto cellvar =
dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 8), "Wrong result for ExtractCells");
@ -229,7 +229,7 @@ public:
extractOnlyBoundaryCells);
auto cellvar =
dataset.GetField("cellvar").GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32>>();
dataset.GetField("cellvar").GetData().AsArrayHandle<vtkm::cont::ArrayHandle<vtkm::Float32>>();
auto cellFieldArray = extractGeometry.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 8), "Wrong result for ExtractCells");

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

@ -290,13 +290,13 @@ void TestFieldHistogram()
// Get point data
vtkm::cont::ArrayHandle<vtkm::Float32> p_poisson;
ds.GetField("p_poisson").GetData().CopyTo(p_poisson);
ds.GetField("p_poisson").GetData().AsArrayHandle(p_poisson);
vtkm::cont::ArrayHandle<vtkm::Float32> p_normal;
ds.GetField("p_normal").GetData().CopyTo(p_normal);
ds.GetField("p_normal").GetData().AsArrayHandle(p_normal);
vtkm::cont::ArrayHandle<vtkm::Float32> p_chiSquare;
ds.GetField("p_chiSquare").GetData().CopyTo(p_chiSquare);
ds.GetField("p_chiSquare").GetData().AsArrayHandle(p_chiSquare);
vtkm::cont::ArrayHandle<vtkm::Float32> p_uniform;
ds.GetField("p_uniform").GetData().CopyTo(p_uniform);
ds.GetField("p_uniform").GetData().AsArrayHandle(p_uniform);
vtkm::worklet::FieldHistogram histogram;
// Run data

10
vtkm/worklet/testing/UnitTestFieldStatistics.cxx
View File

@ -319,7 +319,7 @@ void TestFieldSimple()
// Cell data
vtkm::cont::ArrayHandle<vtkm::Float32> data;
ds.GetField("data").GetData().CopyTo(data);
ds.GetField("data").GetData().AsArrayHandle(data);
// Run
vtkm::worklet::FieldStatistics<vtkm::Float32>().Run(data, statinfo);
@ -350,13 +350,13 @@ void TestFieldStandardDistributions()
// Point data
vtkm::cont::ArrayHandle<vtkm::Float32> p_poisson;
ds.GetField("p_poisson").GetData().CopyTo(p_poisson);
ds.GetField("p_poisson").GetData().AsArrayHandle(p_poisson);
vtkm::cont::ArrayHandle<vtkm::Float32> p_normal;
ds.GetField("p_normal").GetData().CopyTo(p_normal);
ds.GetField("p_normal").GetData().AsArrayHandle(p_normal);
vtkm::cont::ArrayHandle<vtkm::Float32> p_chiSquare;
ds.GetField("p_chiSquare").GetData().CopyTo(p_chiSquare);
ds.GetField("p_chiSquare").GetData().AsArrayHandle(p_chiSquare);
vtkm::cont::ArrayHandle<vtkm::Float32> p_uniform;
ds.GetField("p_uniform").GetData().CopyTo(p_uniform);
ds.GetField("p_uniform").GetData().AsArrayHandle(p_uniform);
// Run Poisson data
vtkm::worklet::FieldStatistics<vtkm::Float32>().Run(p_poisson, statinfo);

6
vtkm/worklet/testing/UnitTestMask.cxx
View File

@ -43,7 +43,7 @@ public:
OutCellSetType outCellSet = maskCells.Run(cellSet, 2);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = maskCells.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 8), "Wrong result for Mask");
@ -69,7 +69,7 @@ public:
OutCellSetType outCellSet = maskCells.Run(cellSet, 9);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = maskCells.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 7), "Wrong result for ExtractCells");
@ -96,7 +96,7 @@ public:
OutCellSetType outCellSet = maskCells.Run(cellSet, 2);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = maskCells.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), 2), "Wrong result for ExtractCells");

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

@ -352,8 +352,8 @@ void TestOrientNormals(bool testPoints, bool testCells)
const auto pointNormalField = dataset.GetPointField("normals");
const auto cellNormalField = dataset.GetCellField("normals");
auto pointNormals = pointNormalField.GetData().Cast<NormalArrayT>();
auto cellNormals = cellNormalField.GetData().Cast<NormalArrayT>();
auto pointNormals = pointNormalField.GetData().AsArrayHandle<NormalArrayT>();
auto cellNormals = cellNormalField.GetData().AsArrayHandle<NormalArrayT>();
vtkm::worklet::OrientNormals::RunPointAndCellNormals(cells, coords, pointNormals, cellNormals);
}
@ -361,7 +361,7 @@ void TestOrientNormals(bool testPoints, bool testCells)
{
std::cerr << "Testing point normals...\n";
const auto pointNormalField = dataset.GetPointField("normals");
auto pointNormals = pointNormalField.GetData().Cast<NormalArrayT>();
auto pointNormals = pointNormalField.GetData().AsArrayHandle<NormalArrayT>();
vtkm::worklet::OrientNormals::RunPointNormals(cells, coords, pointNormals);
}
@ -369,7 +369,7 @@ void TestOrientNormals(bool testPoints, bool testCells)
{
std::cerr << "Testing cell normals...\n";
const auto cellNormalField = dataset.GetCellField("normals");
auto cellNormals = cellNormalField.GetData().Cast<NormalArrayT>();
auto cellNormals = cellNormalField.GetData().AsArrayHandle<NormalArrayT>();
vtkm::worklet::OrientNormals::RunCellNormals(cells, coords, cellNormals);
}

5
vtkm/worklet/testing/UnitTestParticleAdvection.cxx
View File

@ -836,9 +836,10 @@ void TestParticleAdvectionFile(const std::string& fname,
// If types match, do a simple cast.
// If not, need to copy it into the appropriate type.
if (fieldData.IsType<FieldHandle>())
fieldArray = fieldData.Cast<FieldHandle>();
fieldArray = fieldData.AsArrayHandle<FieldHandle>();
else
vtkm::cont::ArrayCopy(fieldData.ResetTypes<vtkm::TypeListFieldVec3>(), fieldArray);
vtkm::cont::ArrayCopy(
fieldData.ResetTypes<vtkm::TypeListFieldVec3, VTKM_DEFAULT_STORAGE_LIST>(), fieldArray);
FieldType velocities(fieldArray);
GridEvalType eval(ds.GetCoordinateSystem(), ds.GetCellSet(), velocities);

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

@ -25,7 +25,7 @@ void TestPointGradientUniform2D()
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
vtkm::worklet::PointGradient gradient;
auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);
@ -51,7 +51,7 @@ void TestPointGradientUniform3D()
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
vtkm::worklet::PointGradient gradient;
auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);
@ -202,7 +202,7 @@ void TestPointGradientExplicit3D()
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet5();
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
vtkm::worklet::PointGradient gradient;
auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);
@ -235,7 +235,7 @@ void TestPointGradientExplicit2D()
vtkm::cont::DataSet dataSet = testDataSet.Make2DExplicitDataSet0();
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
dataSet.GetField("pointvar").GetData().CopyTo(fieldArray);
dataSet.GetField("pointvar").GetData().AsArrayHandle(fieldArray);
vtkm::worklet::PointGradient gradient;
auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), fieldArray);

24
vtkm/worklet/testing/UnitTestProbe.cxx
View File

@ -133,10 +133,10 @@ private:
vtkm::worklet::Probe probe;
probe.Run(input.GetCellSet(), input.GetCoordinateSystem(), geometry.GetCoordinateSystem());
auto pf =
probe.ProcessPointField(input.GetField("pointdata").GetData().Cast<FieldArrayType>(), 0.0f);
auto cf =
probe.ProcessCellField(input.GetField("celldata").GetData().Cast<FieldArrayType>(), 0.0f);
auto pf = probe.ProcessPointField(
input.GetField("pointdata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
auto cf = probe.ProcessCellField(
input.GetField("celldata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
auto hp = probe.GetHiddenPointsField();
auto hc = probe.GetHiddenCellsField(geometry.GetCellSet());
@ -156,10 +156,10 @@ private:
vtkm::worklet::Probe probe;
probe.Run(input.GetCellSet(), input.GetCoordinateSystem(), geometry.GetCoordinateSystem());
auto pf =
probe.ProcessPointField(input.GetField("pointdata").GetData().Cast<FieldArrayType>(), 0.0f);
auto cf =
probe.ProcessCellField(input.GetField("celldata").GetData().Cast<FieldArrayType>(), 0.0f);
auto pf = probe.ProcessPointField(
input.GetField("pointdata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
auto cf = probe.ProcessCellField(
input.GetField("celldata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
auto hp = probe.GetHiddenPointsField();
auto hc = probe.GetHiddenCellsField(geometry.GetCellSet());
@ -180,10 +180,10 @@ private:
vtkm::worklet::Probe probe;
probe.Run(input.GetCellSet(), input.GetCoordinateSystem(), geometry.GetCoordinateSystem());
auto pf =
probe.ProcessPointField(input.GetField("pointdata").GetData().Cast<FieldArrayType>(), 0.0f);
auto cf =
probe.ProcessCellField(input.GetField("celldata").GetData().Cast<FieldArrayType>(), 0.0f);
auto pf = probe.ProcessPointField(
input.GetField("pointdata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
auto cf = probe.ProcessCellField(
input.GetField("celldata").GetData().AsArrayHandle<FieldArrayType>(), 0.0f);
auto hp = probe.GetHiddenPointsField();
auto hc = probe.GetHiddenCellsField(geometry.GetCellSet());

4
vtkm/worklet/testing/UnitTestSplitSharpEdges.cxx
View File

@ -126,7 +126,7 @@ void TestSplitSharpEdgesSplitEveryEdge(vtkm::cont::DataSet& simpleCube,
newCellset);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> pointvar;
simpleCube.GetPointField("pointvar").GetData().CopyTo(pointvar);
simpleCube.GetPointField("pointvar").GetData().AsArrayHandle(pointvar);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointFields =
splitSharpEdges.ProcessPointField(pointvar);
VTKM_TEST_ASSERT(newCoords.GetNumberOfValues() == 24,
@ -171,7 +171,7 @@ void TestSplitSharpEdgesNoSplit(vtkm::cont::DataSet& simpleCube,
newCellset);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> pointvar;
simpleCube.GetPointField("pointvar").GetData().CopyTo(pointvar);
simpleCube.GetPointField("pointvar").GetData().AsArrayHandle(pointvar);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> newPointFields =
splitSharpEdges.ProcessPointField(pointvar);
VTKM_TEST_ASSERT(newCoords.GetNumberOfValues() == 8,

10
vtkm/worklet/testing/UnitTestThreshold.cxx
View File

@ -59,7 +59,7 @@ public:
dataset.GetCellSet().CopyTo(cellset);
vtkm::cont::ArrayHandle<vtkm::Float32> pointvar;
dataset.GetField("pointvar").GetData().CopyTo(pointvar);
dataset.GetField("pointvar").GetData().AsArrayHandle(pointvar);
vtkm::worklet::Threshold threshold;
OutCellSetType outCellSet =
@ -68,7 +68,7 @@ public:
VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 1, "Wrong number of cells");
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = threshold.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 1 &&
@ -89,7 +89,7 @@ public:
dataset.GetCellSet().CopyTo(cellset);
vtkm::cont::ArrayHandle<vtkm::Float32> pointvar;
dataset.GetField("pointvar").GetData().CopyTo(pointvar);
dataset.GetField("pointvar").GetData().AsArrayHandle(pointvar);
vtkm::worklet::Threshold threshold;
OutCellSetType outCellSet =
@ -98,7 +98,7 @@ public:
VTKM_TEST_ASSERT(outCellSet.GetNumberOfCells() == 2, "Wrong number of cells");
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
vtkm::cont::ArrayHandle<vtkm::Float32> cellFieldArray = threshold.ProcessCellField(cellvar);
VTKM_TEST_ASSERT(cellFieldArray.GetNumberOfValues() == 2 &&
@ -120,7 +120,7 @@ public:
dataset.GetCellSet().CopyTo(cellset);
vtkm::cont::ArrayHandle<vtkm::Float32> cellvar;
dataset.GetField("cellvar").GetData().CopyTo(cellvar);
dataset.GetField("cellvar").GetData().AsArrayHandle(cellvar);
vtkm::worklet::Threshold threshold;
OutCellSetType outCellSet =

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

@ -109,7 +109,9 @@ public:
OutCellSetType outCellSet;
outCellSet =
threshold.Run(dataset.GetCellSet(),
dataset.GetField("pointvar").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
dataset.GetField("pointvar")
.GetData()
.ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
ValuesBetween(40.0f, 71.0f));
outDataSet.SetCellSet(outCellSet);
@ -118,7 +120,7 @@ public:
vtkm::cont::Field pointField = outDataSet.GetField("pointvar");
vtkm::cont::ArrayHandle<vtkm::Float32> pointFieldArray;
pointField.GetData().CopyTo(pointFieldArray);
pointField.GetData().AsArrayHandle(pointFieldArray);
VTKM_TEST_ASSERT(pointFieldArray.ReadPortal().Get(12) == 50.0f, "Wrong point field data");
}
@ -140,7 +142,9 @@ public:
OutCellSetType outCellSet;
outCellSet =
threshold.Run(dataset.GetCellSet(),
dataset.GetField("pointvar").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
dataset.GetField("pointvar")
.GetData()
.ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
ValuesAbove(1.0f));
outDataSet.SetCellSet(outCellSet);
@ -165,7 +169,9 @@ public:
OutCellSetType outCellSet;
outCellSet =
threshold.Run(dataset.GetCellSet(),
dataset.GetField("pointvar").GetData().ResetTypes(vtkm::TypeListFieldScalar()),
dataset.GetField("pointvar")
.GetData()
.ResetTypes(vtkm::TypeListFieldScalar{}, VTKM_DEFAULT_STORAGE_LIST{}),
ValuesBelow(50.0f));
outDataSet.SetCellSet(outCellSet);

4
vtkm/worklet/testing/UnitTestTriangleWinding.cxx
View File

@ -60,7 +60,7 @@ void Validate(vtkm::cont::DataSet dataSet)
cellSet.GetOffsetsArray(vtkm::TopologyElementTagCell{}, vtkm::TopologyElementTagPoint{});
const auto cellArray = vtkm::cont::make_ArrayHandleGroupVecVariable(conn, offsets);
const auto cellNormalsVar = dataSet.GetCellField("normals").GetData();
const auto cellNormalsArray = cellNormalsVar.Cast<vtkm::cont::ArrayHandle<MyNormalT>>();
const auto cellNormalsArray = cellNormalsVar.AsArrayHandle<vtkm::cont::ArrayHandle<MyNormalT>>();
const auto cellPortal = cellArray.ReadPortal();
const auto cellNormals = cellNormalsArray.ReadPortal();
@ -112,7 +112,7 @@ void DoTest()
auto cellSet = ds.GetCellSet().Cast<vtkm::cont::CellSetExplicit<>>();
const auto coords = ds.GetCoordinateSystem().GetData();
const auto cellNormalsVar = ds.GetCellField("normals").GetData();
const auto cellNormals = cellNormalsVar.Cast<vtkm::cont::ArrayHandle<MyNormalT>>();
const auto cellNormals = cellNormalsVar.AsArrayHandle<vtkm::cont::ArrayHandle<MyNormalT>>();
auto newCells = vtkm::worklet::TriangleWinding::Run(cellSet, coords, cellNormals);

Some files were not shown because too many files have changed in this diff Show More