Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge topic 'array-range-compute-hidden'

Browse Source 
5355a432 Remove unnecessary library dependencies
6fdc7eb8 Add Field::GetRange and CoordinateSystem::GetBounds to library
c16236ce Use ArrayRangeCompute without specifying a device

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !710
This commit is contained in:
Kenneth Moreland 2017-03-09 21:25:35 +00:00 committed by Kitware Robot
commit 6bf8f26ed0
22 changed files with 584 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMake/VTKmMacros.cmake
View File

@ -606,6 +606,7 @@ endfunction(vtkm_wrap_sources_for_cuda)
# [HEADERS <headers_list>]
# [CUDA]
# [WRAP_FOR_CUDA <source_list>]
# [LIBRARIES <dependent_library_list>]
# )
function(vtkm_library)
set(options CUDA)
@ -667,8 +668,11 @@ function(vtkm_library)
add_library(${lib_name} ${VTKm_LIB_SOURCES})
endif()
#need to link to the vtkm target as makes C++11 become enabled
target_link_libraries(${lib_name} PUBLIC vtkm)
target_link_libraries(${lib_name} PRIVATE
${VTKm_BACKEND_LIBRARIES}
${VTKm_LIB_LIBRARIES}
)
set(cxx_args ${VTKm_COMPILE_OPTIONS})
separate_arguments(cxx_args)

141
vtkm/cont/ArrayRangeCompute.cxx Normal file
View File

@ -0,0 +1,141 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2017 Sandia Corporation.
// Copyright 2017 UT-Battelle, LLC.
// Copyright 2017 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/cont/ArrayRangeCompute.hxx>
namespace vtkm {
namespace cont {
#define VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(T, Storage) \
VTKM_CONT \
vtkm::cont::ArrayHandle<vtkm::Range> \
ArrayRangeCompute(const vtkm::cont::ArrayHandle<T, Storage> &input, \
vtkm::cont::RuntimeDeviceTracker tracker) \
{ \
return detail::ArrayRangeComputeImpl(input,tracker); \
} \
struct SwallowSemicolon
#define VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(T, N, Storage) \
VTKM_CONT \
vtkm::cont::ArrayHandle<vtkm::Range> \
ArrayRangeCompute(const vtkm::cont::ArrayHandle<vtkm::Vec<T,N>, Storage> &input, \
vtkm::cont::RuntimeDeviceTracker tracker) \
{ \
return detail::ArrayRangeComputeImpl(input,tracker); \
} \
struct SwallowSemicolon
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(char, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::Int8, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::UInt8, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::Int16, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::UInt16, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::Int32, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::UInt32, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::Int64, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::UInt64, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::Float32, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_T(vtkm::Float64, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Int32, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Int64, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Float32, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Float64, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Int32, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Int64, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Float32, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Float64, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(char, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Int8, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::UInt8, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Float32, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC(vtkm::Float64, 4, vtkm::cont::StorageTagBasic);
#undef VTKM_ARRAY_RANGE_COMPUTE_IMPL_T
#undef VTKM_ARRAY_RANGE_COMPUTE_IMPL_VEC
// Special implementation for regular point coordinates, which are easy
// to determine.
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
&array,
vtkm::cont::RuntimeDeviceTracker)
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
vtkm::Vec<vtkm::FloatDefault,3> minimum = portal.Get(0);
vtkm::Vec<vtkm::FloatDefault,3> maximum =
portal.Get(portal.GetNumberOfValues()-1);
vtkm::cont::ArrayHandle<vtkm::Range> rangeArray;
rangeArray.Allocate(3);
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl outPortal =
rangeArray.GetPortalControl();
outPortal.Set(0, vtkm::Range(minimum[0], maximum[0]));
outPortal.Set(1, vtkm::Range(minimum[1], maximum[1]));
outPortal.Set(2, vtkm::Range(minimum[2], maximum[2]));
return rangeArray;
}
// Special implementation for composite vectors.
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::Float32,3>,
typename vtkm::cont::ArrayHandleCompositeVector<
vtkm::Vec<vtkm::Float32,3>(
vtkm::cont::ArrayHandle<vtkm::Float32>,
vtkm::cont::ArrayHandle<vtkm::Float32>,
vtkm::cont::ArrayHandle<vtkm::Float32>)
>::StorageTag
> &input,
vtkm::cont::RuntimeDeviceTracker tracker)
{
return detail::ArrayRangeComputeImpl(input,tracker);
}
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::Float64,3>,
typename vtkm::cont::ArrayHandleCompositeVector<
vtkm::Vec<vtkm::Float64,3>(
vtkm::cont::ArrayHandle<vtkm::Float64>,
vtkm::cont::ArrayHandle<vtkm::Float64>,
vtkm::cont::ArrayHandle<vtkm::Float64>)
>::StorageTag
> &input,
vtkm::cont::RuntimeDeviceTracker tracker)
{
return detail::ArrayRangeComputeImpl(input,tracker);
}
}
} // namespace vtkm::cont

188
vtkm/cont/ArrayRangeCompute.h
View File

@ -20,110 +20,156 @@
#ifndef vtk_m_cont_ArrayRangeCompute_h
#define vtk_m_cont_ArrayRangeCompute_h
#include <vtkm/BinaryOperators.h>
#include <vtkm/Range.h>
#include <vtkm/VecTraits.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCartesianProduct.h>
#include <vtkm/cont/ArrayHandleCompositeVector.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
namespace vtkm {
namespace cont {
namespace internal {
struct RangeMin
{
template<typename T>
VTKM_EXEC
T operator()(const T& a, const T& b)const { return vtkm::Min(a,b); }
};
struct RangeMax
{
template<typename T>
VTKM_EXEC
T operator()(const T& a, const T& b)const { return vtkm::Max(a,b); }
};
} // namespace internal
/// \brief Compute the range of the data in an array handle.
///
/// Given an \c ArrayHandle, this function computes the range (min and max) of
/// the values in the array. For arrays containing Vec values, the range is
/// computed for each component.
///
/// This method also takes a device adapter tag to specify the device on which
/// to compute the range.
///This method optionally takes a \c RuntimeDeviceTracker to control which
///devices to try.
///
/// The result is returned in an \c ArrayHandle of \c Range objects. There is
/// one value in the returned array for every component of the input's value
/// type.
///
template<typename ArrayHandleType, typename Device>
inline
template<typename ArrayHandleType>
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const ArrayHandleType &input, Device)
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
ArrayRangeCompute(const ArrayHandleType &input,
vtkm::cont::RuntimeDeviceTracker tracker =
vtkm::cont::GetGlobalRuntimeDeviceTracker());
typedef typename ArrayHandleType::ValueType ValueType;
typedef vtkm::VecTraits<ValueType> VecType;
const vtkm::IdComponent NumberOfComponents = VecType::NUM_COMPONENTS;
// Precompiled versions of ArrayRangeCompute
#define VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(T, Storage) \
VTKM_CONT_EXPORT \
VTKM_CONT \
vtkm::cont::ArrayHandle<vtkm::Range> \
ArrayRangeCompute(const vtkm::cont::ArrayHandle<T, Storage> &input, \
vtkm::cont::RuntimeDeviceTracker tracker = \
vtkm::cont::GetGlobalRuntimeDeviceTracker())
#define VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(T, N, Storage) \
VTKM_CONT_EXPORT \
VTKM_CONT \
vtkm::cont::ArrayHandle<vtkm::Range> \
ArrayRangeCompute(const vtkm::cont::ArrayHandle<vtkm::Vec<T,N>, Storage> &input, \
vtkm::cont::RuntimeDeviceTracker tracker = \
vtkm::cont::GetGlobalRuntimeDeviceTracker())
typedef vtkm::cont::DeviceAdapterAlgorithm<Device> Algorithm;
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(char, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::Int8, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::UInt8, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::Int16, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::UInt16, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::Int32, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::UInt32, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::Int64, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::UInt64, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::Float32, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T(vtkm::Float64, vtkm::cont::StorageTagBasic);
//not the greatest way of doing this for performance reasons. But
//this implementation should generate the smallest amount of code
vtkm::Vec<ValueType,2> initial(input.GetPortalConstControl().Get(0));
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Int32, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Int64, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Float32, 2, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Float64, 2, vtkm::cont::StorageTagBasic);
vtkm::Vec<ValueType, 2> result =
Algorithm::Reduce(input, initial, vtkm::MinAndMax<ValueType>());
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Int32, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Int64, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Float32, 3, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Float64, 3, vtkm::cont::StorageTagBasic);
vtkm::cont::ArrayHandle<vtkm::Range> rangeArray;
rangeArray.Allocate(NumberOfComponents);
for (vtkm::IdComponent i = 0; i < NumberOfComponents; ++i)
{
rangeArray.GetPortalControl().Set(
i, vtkm::Range(VecType::GetComponent(result[0], i),
VecType::GetComponent(result[1], i)));
}
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(char, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Int8, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::UInt8, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Float32, 4, vtkm::cont::StorageTagBasic);
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(vtkm::Float64, 4, vtkm::cont::StorageTagBasic);
return rangeArray;
}
VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC(
vtkm::FloatDefault, 3,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag);
// Special implementation for regular point coordinates, which are easy
// to determine.
template<typename Device>
inline
#undef VTKM_ARRAY_RANGE_COMPUTE_EXPORT_T
#undef VTKM_ARRAY_RANGE_COMPUTE_EXPORT_VEC
// Implementation of composite vectors
VTKM_CONT_EXPORT
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
&array,
Device)
vtkm::Vec<vtkm::Float32,3>,
typename vtkm::cont::ArrayHandleCompositeVector<
vtkm::Vec<vtkm::Float32,3>(
vtkm::cont::ArrayHandle<vtkm::Float32>,
vtkm::cont::ArrayHandle<vtkm::Float32>,
vtkm::cont::ArrayHandle<vtkm::Float32>)
>::StorageTag
> &input,
vtkm::cont::RuntimeDeviceTracker tracker =
vtkm::cont::GetGlobalRuntimeDeviceTracker());
VTKM_CONT_EXPORT
VTKM_CONT
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::Float64,3>,
typename vtkm::cont::ArrayHandleCompositeVector<
vtkm::Vec<vtkm::Float64,3>(
vtkm::cont::ArrayHandle<vtkm::Float64>,
vtkm::cont::ArrayHandle<vtkm::Float64>,
vtkm::cont::ArrayHandle<vtkm::Float64>)
>::StorageTag
> &input,
vtkm::cont::RuntimeDeviceTracker tracker =
vtkm::cont::GetGlobalRuntimeDeviceTracker());
// Implementation of cartesian products
template<typename T,
typename ArrayType1,
typename ArrayType2,
typename ArrayType3>
VTKM_CONT
inline
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<T,
vtkm::cont::internal::StorageTagCartesianProduct<
ArrayType1,ArrayType2,ArrayType3
> > &input,
vtkm::cont::RuntimeDeviceTracker tracker =
vtkm::cont::GetGlobalRuntimeDeviceTracker())
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
vtkm::cont::ArrayHandle<vtkm::Range> result;
result.Allocate(3);
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
vtkm::Vec<vtkm::FloatDefault,3> minimum = portal.Get(0);
vtkm::Vec<vtkm::FloatDefault,3> maximum =
portal.Get(portal.GetNumberOfValues()-1);
vtkm::cont::ArrayHandle<vtkm::Range> componentRangeArray;
vtkm::Range componentRange;
vtkm::cont::ArrayHandle<vtkm::Range> rangeArray;
rangeArray.Allocate(3);
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl outPortal =
rangeArray.GetPortalControl();
outPortal.Set(0, vtkm::Range(minimum[0], maximum[0]));
outPortal.Set(1, vtkm::Range(minimum[1], maximum[1]));
outPortal.Set(2, vtkm::Range(minimum[2], maximum[2]));
ArrayType1 firstArray = input.GetStorage().GetFirstArray();
componentRangeArray = vtkm::cont::ArrayRangeCompute(firstArray, tracker);
componentRange = componentRangeArray.GetPortalConstControl().Get(0);
result.GetPortalControl().Set(0, componentRange);
return rangeArray;
ArrayType2 secondArray = input.GetStorage().GetSecondArray();
componentRangeArray = vtkm::cont::ArrayRangeCompute(secondArray, tracker);
componentRange = componentRangeArray.GetPortalConstControl().Get(0);
result.GetPortalControl().Set(1, componentRange);
ArrayType3 thirdArray = input.GetStorage().GetThirdArray();
componentRangeArray = vtkm::cont::ArrayRangeCompute(thirdArray, tracker);
componentRange = componentRangeArray.GetPortalConstControl().Get(0);
result.GetPortalControl().Set(2, componentRange);
return result;
}
}

124
vtkm/cont/ArrayRangeCompute.hxx Normal file
View File

@ -0,0 +1,124 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2017 Sandia Corporation.
// Copyright 2017 UT-Battelle, LLC.
// Copyright 2017 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ArrayRangeCompute_hxx
#define vtk_m_cont_ArrayRangeCompute_hxx
#include <vtkm/cont/ArrayRangeCompute.h>
#include <vtkm/BinaryOperators.h>
#include <vtkm/VecTraits.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/TryExecute.h>
namespace vtkm {
namespace cont {
namespace detail {
template<typename ArrayHandleType>
struct ArrayRangeComputeFunctor
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
ArrayHandleType InputArray;
vtkm::cont::ArrayHandle<vtkm::Range> RangeArray;
VTKM_CONT
ArrayRangeComputeFunctor(const ArrayHandleType &input)
: InputArray(input)
{ }
template<typename Device>
VTKM_CONT
bool operator()(Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
using ValueType = typename ArrayHandleType::ValueType;
using VecTraits = vtkm::VecTraits<ValueType>;
const vtkm::IdComponent NumberOfComponents = VecTraits::NUM_COMPONENTS;
typedef vtkm::cont::DeviceAdapterAlgorithm<Device> Algorithm;
if (this->InputArray.GetNumberOfValues() < 1)
{
throw vtkm::cont::ErrorBadValue(
"Called ArrayComputeRange on empty array (which has no range).");
}
vtkm::Vec<ValueType,2> initial(
this->InputArray.GetPortalConstControl().Get(0));
vtkm::Vec<ValueType, 2> result =
Algorithm::Reduce(this->InputArray,
initial,
vtkm::MinAndMax<ValueType>());
this->RangeArray.Allocate(NumberOfComponents);
for (vtkm::IdComponent i = 0; i < NumberOfComponents; ++i)
{
this->RangeArray.GetPortalControl().Set(
i, vtkm::Range(VecTraits::GetComponent(result[0], i),
VecTraits::GetComponent(result[1], i)));
}
return true;
}
};
template<typename ArrayHandleType>
inline
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeComputeImpl(const ArrayHandleType &input,
vtkm::cont::RuntimeDeviceTracker tracker)
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
detail::ArrayRangeComputeFunctor<ArrayHandleType> functor(input);
if (!vtkm::cont::TryExecute(functor, tracker))
{
throw vtkm::cont::ErrorExecution(
"Failed to run ArrayRangeComputation on any device.");
}
return functor.RangeArray;
}
} // namespace detail
template<typename ArrayHandleType>
inline
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const ArrayHandleType &input,
vtkm::cont::RuntimeDeviceTracker tracker)
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
return detail::ArrayRangeComputeImpl(input, tracker);
}
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ArrayRangeCompute_hxx

2
vtkm/cont/CMakeLists.txt
View File

@ -39,6 +39,7 @@ set(headers
ArrayPortalToIterators.h
ArrayHandleConcatenate.h
ArrayRangeCompute.h
ArrayRangeCompute.hxx
CellSet.h
CellSetExplicit.h
CellSetListTag.h
@ -93,6 +94,7 @@ set(sources
# This list of sources has code that uses devices and so might need to be
# compiled with a device-specific compiler (like CUDA).
set(device_sources
ArrayRangeCompute.cxx
RuntimeDeviceTracker.cxx
)

26
vtkm/cont/CoordinateSystem.cxx
View File

@ -23,11 +23,37 @@
namespace vtkm {
namespace cont {
VTKM_CONT
void CoordinateSystem::PrintSummary(std::ostream &out) const
{
out << " Coordinate System ";
this->Superclass::PrintSummary(out);
}
VTKM_CONT
void CoordinateSystem::GetRange(vtkm::Range *range) const
{
this->Superclass::GetRange(
range,
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>&
CoordinateSystem::GetRange() const
{
return this->Superclass::GetRange(
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
VTKM_CONT
vtkm::Bounds CoordinateSystem::GetBounds() const
{
return this->GetBounds(VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
}
} // namespace vtkm::cont

146
vtkm/cont/CoordinateSystem.h
View File

@ -142,105 +142,83 @@ public:
this->Superclass::GetData());
}
template<typename DeviceAdapterTag>
VTKM_CONT
void GetRange(vtkm::Range *range, DeviceAdapterTag) const
{
this->Superclass::GetRange(
range,
DeviceAdapterTag(),
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
void GetRange(vtkm::Range *range) const;
template<typename DeviceAdapterTag, typename TypeList>
template<typename TypeList>
VTKM_CONT
void GetRange(vtkm::Range *range, DeviceAdapterTag, TypeList) const
void GetRange(vtkm::Range *range, TypeList) const
{
this->Superclass::GetRange(
range,
DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
VTKM_CONT
void GetRange(vtkm::Range *range, DeviceAdapterTag, TypeList, StorageList) const
{
this->Superclass::GetRange(
range,
DeviceAdapterTag(),
TypeList(),
StorageList());
}
template<typename DeviceAdapterTag>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag) const
{
return this->Superclass::GetRange(
DeviceAdapterTag(),
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag,
TypeList) const
{
return this->Superclass::GetRange(
DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag,
TypeList,
StorageList) const
{
return this->Superclass::GetRange(
DeviceAdapterTag(),
TypeList(),
StorageList());
}
template<typename DeviceAdapterTag>
VTKM_CONT
vtkm::Bounds GetBounds(DeviceAdapterTag) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
return this->GetBounds(DeviceAdapterTag(),
VTKM_DEFAULT_COORDINATE_SYSTEM_TYPE_LIST_TAG(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList>
VTKM_CONT
vtkm::Bounds GetBounds(DeviceAdapterTag, TypeList) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
VTKM_IS_LIST_TAG(TypeList);
return this->GetBounds(DeviceAdapterTag(),
TypeList(),
this->Superclass::GetRange(
range,
TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename TypeList, typename StorageList>
VTKM_CONT
void GetRange(vtkm::Range *range, TypeList, StorageList) const
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
this->Superclass::GetRange(
range,
TypeList(),
StorageList());
}
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange() const;
template<typename TypeList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(TypeList) const
{
VTKM_IS_LIST_TAG(TypeList);
return this->Superclass::GetRange(
TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename TypeList, typename StorageList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(TypeList,
StorageList) const
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
return this->Superclass::GetRange(
TypeList(),
StorageList());
}
VTKM_CONT
vtkm::Bounds GetBounds() const;
template<typename TypeList>
VTKM_CONT
vtkm::Bounds GetBounds(TypeList) const
{
VTKM_IS_LIST_TAG(TypeList);
return this->GetBounds(TypeList(),
VTKM_DEFAULT_COORDINATE_SYSTEM_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
template<typename TypeList, typename StorageList>
VTKM_CONT
vtkm::Bounds GetBounds(DeviceAdapterTag, TypeList, StorageList) const
vtkm::Bounds GetBounds(TypeList, StorageList) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
vtkm::cont::ArrayHandle<vtkm::Range> ranges =
this->GetRange(DeviceAdapterTag(), TypeList(), StorageList());
this->GetRange(TypeList(), StorageList());
VTKM_ASSERT(ranges.GetNumberOfValues() == 3);

44
vtkm/cont/Field.cxx
View File

@ -23,30 +23,56 @@
namespace vtkm {
namespace cont {
VTKM_CONT
void Field::PrintSummary(std::ostream &out) const
{
out<<" "<<this->Name;
out<<" assoc= ";
switch (this->GetAssociation())
{
out<<" "<<this->Name;
out<<" assoc= ";
switch (this->GetAssociation())
{
case ASSOC_ANY: out<<"Any "; break;
case ASSOC_WHOLE_MESH: out<<"Mesh "; break;
case ASSOC_POINTS: out<<"Points "; break;
case ASSOC_CELL_SET: out<<"Cells "; break;
case ASSOC_LOGICAL_DIM: out<<"LogicalDim "; break;
}
this->Data.PrintSummary(out);
}
this->Data.PrintSummary(out);
}
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range> &
Field::GetRange() const
{
return this->GetRange(VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
VTKM_CONT
void Field::GetRange(vtkm::Range *range) const
{
this->GetRange(range,
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
VTKM_CONT
const vtkm::cont::DynamicArrayHandle &Field::GetData() const
{
return this->Data;
return this->Data;
}
VTKM_CONT
vtkm::cont::DynamicArrayHandle &Field::GetData()
{
this->ModifiedFlag = true;
return this->Data;
this->ModifiedFlag = true;
return this->Data;
}
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range> &
Field::GetRange(VTKM_DEFAULT_TYPE_LIST_TAG, VTKM_DEFAULT_STORAGE_LIST_TAG) const
{
return this->GetRangeImpl(VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());
}
}

93
vtkm/cont/Field.h
View File

@ -22,27 +22,19 @@
#include <vtkm/cont/vtkm_cont_export.h>
#include <vtkm/Math.h>
#include <vtkm/Range.h>
#include <vtkm/Types.h>
#include <vtkm/VecTraits.h>
#include <vtkm/BinaryOperators.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ArrayRangeCompute.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/internal/ArrayPortalFromIterators.h>
namespace vtkm {
namespace cont {
namespace internal {
template<typename DeviceAdapterTag>
class ComputeRange
{
public:
@ -51,7 +43,7 @@ public:
template<typename ArrayHandleType>
void operator()(const ArrayHandleType &input) const
{
*this->Range = vtkm::cont::ArrayRangeCompute(input, DeviceAdapterTag());
*this->Range = vtkm::cont::ArrayRangeCompute(input);
}
private:
@ -320,30 +312,31 @@ public:
return this->AssocLogicalDim;
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
template<typename TypeList, typename StorageList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag,
TypeList,
StorageList) const
const vtkm::cont::ArrayHandle<vtkm::Range>&
GetRange(TypeList, StorageList) const
{
if (this->ModifiedFlag)
{
internal::ComputeRange<DeviceAdapterTag> computeRange(this->Range);
this->Data.ResetTypeAndStorageLists(TypeList(),StorageList()).CastAndCall(computeRange);
this->ModifiedFlag = false;
}
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
return this->Range;
return this->GetRangeImpl(TypeList(), StorageList());
}
template<typename DeviceAdapterTag, typename TypeList, typename StorageList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>&
GetRange(VTKM_DEFAULT_TYPE_LIST_TAG, VTKM_DEFAULT_STORAGE_LIST_TAG) const;
template<typename TypeList, typename StorageList>
VTKM_CONT
void GetRange(vtkm::Range *range,
DeviceAdapterTag,
TypeList,
StorageList) const
{
this->GetRange(DeviceAdapterTag(), TypeList(), StorageList());
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
this->GetRange(TypeList(), StorageList());
vtkm::Id length = this->Range.GetNumberOfValues();
for (vtkm::Id i = 0; i < length; ++i)
@ -352,44 +345,32 @@ public:
}
}
template<typename DeviceAdapterTag, typename TypeList>
template<typename TypeList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag,
TypeList) const
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(TypeList) const
{
return this->GetRange(DeviceAdapterTag(),
TypeList(),
VTKM_IS_LIST_TAG(TypeList);
return this->GetRange(TypeList(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag, typename TypeList>
template<typename TypeList>
VTKM_CONT
void GetRange(vtkm::Range *range, DeviceAdapterTag, TypeList) const
void GetRange(vtkm::Range *range, TypeList) const
{
VTKM_IS_LIST_TAG(TypeList);
this->GetRange(range,
DeviceAdapterTag(),
TypeList(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
template<typename DeviceAdapterTag>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(DeviceAdapterTag) const
{
return this->GetRange(DeviceAdapterTag(),
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange() const;
template<typename DeviceAdapterTag>
VTKM_CONT
void GetRange(vtkm::Range *range, DeviceAdapterTag) const
{
this->GetRange(range,
DeviceAdapterTag(),
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
void GetRange(vtkm::Range *range) const;
const vtkm::cont::DynamicArrayHandle &GetData() const;
@ -442,6 +423,24 @@ private:
vtkm::cont::DynamicArrayHandle Data;
mutable vtkm::cont::ArrayHandle<vtkm::Range> Range;
mutable bool ModifiedFlag;
template<typename TypeList, typename StorageList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>&
GetRangeImpl(TypeList, StorageList) const
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
if (this->ModifiedFlag)
{
internal::ComputeRange computeRange(this->Range);
this->Data.ResetTypeAndStorageLists(TypeList(),StorageList()).CastAndCall(computeRange);
this->ModifiedFlag = false;
}
return this->Range;
}
};
template<typename Functor>

12
vtkm/cont/testing/TestingComputeRange.h
View File

@ -23,9 +23,11 @@
#include <vtkm/Types.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/Field.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/testing/Testing.h>
// Required for implementation of ArrayRangeCompute for "odd" arrays
#include <vtkm/cont/ArrayRangeCompute.hxx>
#include <algorithm>
#include <iostream>
@ -44,7 +46,7 @@ struct CustomTypeList : vtkm::ListTagBase<vtkm::Vec<Int32, 3>,
vtkm::Vec<Float64, 9> >
{};
template <typename DeviceAdapterTag>
template<typename DeviceAdapterTag>
class TestingComputeRange
{
private:
@ -58,7 +60,7 @@ private:
nvals);
vtkm::Range result;
field.GetRange(&result, DeviceAdapterTag());
field.GetRange(&result);
std::cout << result << std::endl;
VTKM_TEST_ASSERT(
@ -85,7 +87,6 @@ private:
vtkm::Range result[NumberOfComponents];
field.GetRange(result,
DeviceAdapterTag(),
CustomTypeList(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
@ -105,7 +106,7 @@ private:
vtkm::Vec<vtkm::FloatDefault,3>(0.0f,-5.0f,4.0f),
vtkm::Vec<vtkm::FloatDefault,3>(1.0f,0.5f,2.0f));
vtkm::Bounds result = field.GetBounds(DeviceAdapterTag());
vtkm::Bounds result = field.GetBounds();
VTKM_TEST_ASSERT(test_equal(result.X.Min, 0.0), "Min x wrong.");
VTKM_TEST_ASSERT(test_equal(result.X.Max, 9.0), "Max x wrong.");
@ -154,6 +155,7 @@ private:
public:
static VTKM_CONT int Run()
{
vtkm::cont::GetGlobalRuntimeDeviceTracker().ForceDevice(DeviceAdapterTag());
return vtkm::cont::testing::Testing::Run(TestAll());
}
};

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

@ -31,7 +31,6 @@
namespace DataSetBuilderExplicitNamespace {
typedef vtkm::cont::DeviceAdapterAlgorithm<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> DFA;
typedef VTKM_DEFAULT_DEVICE_ADAPTER_TAG DeviceAdapter;
template <typename T>
vtkm::Bounds ComputeBounds(std::size_t numPoints, const T *coords)
@ -83,8 +82,7 @@ void ValidateDataSet(const vtkm::cont::DataSet &ds,
}
//Make sure bounds are correct.
vtkm::Bounds computedBounds =
ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
vtkm::Bounds computedBounds = ds.GetCoordinateSystem().GetBounds();
VTKM_TEST_ASSERT(test_equal(bounds, computedBounds),
"Bounds of coordinates do not match");
}

6
vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
View File

@ -22,7 +22,6 @@
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
@ -35,9 +34,6 @@ namespace DataSetBuilderRectilinearNamespace {
std::mt19937 g_RandomGenerator;
typedef vtkm::cont::DeviceAdapterAlgorithm<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> DFA;
typedef VTKM_DEFAULT_DEVICE_ADAPTER_TAG DeviceAdapter;
void ValidateDataSet(const vtkm::cont::DataSet &ds,
int dim,
vtkm::Id numPoints, vtkm::Id numCells,
@ -75,7 +71,7 @@ void ValidateDataSet(const vtkm::cont::DataSet &ds,
}
//Make sure the bounds are correct.
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds();
VTKM_TEST_ASSERT(test_equal(bounds, res),
"Bounds of coordinates do not match");
if (dim == 2)

6
vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
View File

@ -22,7 +22,6 @@
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/DataSetBuilderUniform.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
@ -35,9 +34,6 @@ namespace DataSetBuilderUniformNamespace {
std::mt19937 g_RandomGenerator;
typedef vtkm::cont::DeviceAdapterAlgorithm<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> DFA;
typedef VTKM_DEFAULT_DEVICE_ADAPTER_TAG DeviceAdapter;
void ValidateDataSet(const vtkm::cont::DataSet &ds,
int dim,
vtkm::Id numPoints, vtkm::Id numCells,
@ -75,7 +71,7 @@ void ValidateDataSet(const vtkm::cont::DataSet &ds,
}
//Make sure bounds are correct.
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds();
VTKM_TEST_ASSERT(test_equal(bounds, res),
"Bounds of coordinates do not match");
if (dim == 1)

19
vtkm/filter/VertexClustering.hxx
View File

@ -21,21 +21,6 @@
namespace vtkm {
namespace filter {
namespace
{
template<typename DerivedPolicy,
typename DeviceAdapter>
vtkm::Bounds compute_bounds(const vtkm::cont::CoordinateSystem& coords,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& tag)
{
typedef typename DerivedPolicy::CoordinateTypeList TypeList;
typedef typename DerivedPolicy::CoordinateStorageList StorageList;
return coords.GetBounds(tag, TypeList(), StorageList());
}
}
//-----------------------------------------------------------------------------
inline VTKM_CONT
VertexClustering::VertexClustering():
@ -59,7 +44,9 @@ vtkm::filter::ResultDataSet VertexClustering::DoExecute(const vtkm::cont::DataSe
//need to compute bounds first
vtkm::Bounds bounds =
compute_bounds(input.GetCoordinateSystem(), policy, tag);
input.GetCoordinateSystem().GetBounds(
typename DerivedPolicy::CoordinateTypeList(),
typename DerivedPolicy::CoordinateStorageList());
vtkm::cont::DataSet outDataSet = clustering.Run(vtkm::filter::ApplyPolicyUnstructured(input.GetCellSet(), policy),
vtkm::filter::ApplyPolicy(input.GetCoordinateSystem(), policy),

32
vtkm/rendering/Actor.cxx
View File

@ -48,34 +48,6 @@ struct Actor::InternalsType
{ }
};
struct Actor::RangeFunctor
{
vtkm::rendering::Actor::InternalsType *Internals;
const vtkm::cont::CoordinateSystem &Coordinates;
const vtkm::cont::Field &ScalarField;
VTKM_CONT
RangeFunctor(vtkm::rendering::Actor *self,
const vtkm::cont::CoordinateSystem &coordinates,
const vtkm::cont::Field &scalarField)
: Internals(self->Internals.get()),
Coordinates(coordinates),
ScalarField(scalarField)
{ }
template<typename Device>
VTKM_CONT
bool operator()(Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
this->ScalarField.GetRange(&this->Internals->ScalarRange, Device());
this->Internals->SpatialBounds = this->Coordinates.GetBounds(Device());
return true;
}
};
Actor::Actor(const vtkm::cont::DynamicCellSet &cells,
const vtkm::cont::CoordinateSystem &coordinates,
const vtkm::cont::Field &scalarField,
@ -84,8 +56,8 @@ Actor::Actor(const vtkm::cont::DynamicCellSet &cells,
{
VTKM_ASSERT(scalarField.GetData().GetNumberOfComponents() == 1);
RangeFunctor functor(this, coordinates, scalarField);
vtkm::cont::TryExecute(functor);
scalarField.GetRange(&this->Internals->ScalarRange);
this->Internals->SpatialBounds = coordinates.GetBounds();
}
void Actor::Render(vtkm::rendering::Mapper &mapper,

2
vtkm/rendering/MapperRayTracer.cxx
View File

@ -142,7 +142,7 @@ struct MapperRayTracer::RenderFunctor
tracer->GetCamera().SetParameters(this->Camera,
*this->Self->Internals->Canvas);
vtkm::Bounds dataBounds = this->Coordinates.GetBounds(Device());
vtkm::Bounds dataBounds = this->Coordinates.GetBounds();
tracer->SetData(this->Coordinates.GetData(),
this->TriangleIndices,

2
vtkm/rendering/MapperVolume.cxx
View File

@ -159,7 +159,7 @@ struct MapperVolume::RenderFunctor
}
tracer->SetCompositeBackground(this->Self->Internals->CompositeBackground);
vtkm::Bounds dataBounds = this->Coordinates.GetBounds(Device());
vtkm::Bounds dataBounds = this->Coordinates.GetBounds();
tracer->SetData(this->Coordinates,
this->ScalarField,

6
vtkm/rendering/testing/RenderTest.h
View File

@ -76,7 +76,7 @@ SetCamera<vtkm::rendering::View1D>(vtkm::rendering::Camera &camera,
{
vtkm::Bounds bounds;
bounds.X = coordBounds.X;
field.GetRange(&bounds.Y, VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
field.GetRange(&bounds.Y);
camera = vtkm::rendering::Camera(vtkm::rendering::Camera::MODE_2D);
camera.ResetToBounds(bounds);
@ -111,7 +111,7 @@ Render(const vtkm::cont::DataSet &ds,
colorTable));
vtkm::rendering::Camera camera;
SetCamera<ViewType>(camera,
ds.GetCoordinateSystem().GetBounds(VTKM_DEFAULT_DEVICE_ADAPTER_TAG()));
ds.GetCoordinateSystem().GetBounds());
ViewType view(scene, mapper, canvas, camera,
vtkm::rendering::Color(0.2f, 0.2f, 0.2f, 1.0f));
@ -134,7 +134,7 @@ Render(const vtkm::cont::DataSet &ds,
ds.GetField(fieldNm)));
vtkm::rendering::Camera camera;
SetCamera<ViewType>(camera,
ds.GetCoordinateSystem().GetBounds(VTKM_DEFAULT_DEVICE_ADAPTER_TAG()),
ds.GetCoordinateSystem().GetBounds(),
ds.GetField(fieldNm));
ViewType view(scene, mapper, canvas, camera,
vtkm::rendering::Color(0.2f, 0.2f, 0.2f, 1.0f));

2
vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx
View File

@ -90,7 +90,7 @@ void RenderTests()
ds[i].GetField(fldNames[i].c_str()),
colorTable));
vtkm::rendering::testing::SetCamera<View3DType>(camera[i],
ds[i].GetCoordinateSystem().GetBounds(VTKM_DEFAULT_DEVICE_ADAPTER_TAG()));
ds[i].GetCoordinateSystem().GetBounds());
}

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

@ -194,7 +194,7 @@ void TestExplicitGrid2D()
std::cout << "Number of output vertices " << coordArray.GetNumberOfValues() << std::endl;
std::cout << "Number of output components " << coordArray.GetNumberOfComponents() << std::endl;
vtkm::Bounds bounds = coordinates.GetBounds(DeviceAdapter());
vtkm::Bounds bounds = coordinates.GetBounds();
std::cout << "Bounds " << bounds << std::endl;
VTKM_TEST_ASSERT(test_equal(cellSet.GetNumberOfCells(), 14), "Wrong result for Triangulate filter");
@ -232,7 +232,7 @@ void TestExplicitGrid3D()
std::cout << "Number of output vertices " << coordArray.GetNumberOfValues() << std::endl;
std::cout << "Number of output components " << coordArray.GetNumberOfComponents() << std::endl;
vtkm::Bounds bounds = coordinates.GetBounds(DeviceAdapter());
vtkm::Bounds bounds = coordinates.GetBounds();
std::cout << "Bounds " << bounds << std::endl;
VTKM_TEST_ASSERT(test_equal(cellSet.GetNumberOfCells(), 11), "Wrong result for Tetrahedralize filter");

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

@ -121,7 +121,7 @@ void TestUniformGrid2D()
std::cout << "Number of output vertices " << coordArray.GetNumberOfValues() << std::endl;
std::cout << "Number of output components " << coordArray.GetNumberOfComponents() << std::endl;
vtkm::Bounds bounds = coordinates.GetBounds(DeviceAdapter());
vtkm::Bounds bounds = coordinates.GetBounds();
std::cout << "Bounds " << bounds << std::endl;
// Two triangles are created for every quad cell
@ -169,7 +169,7 @@ void TestUniformGrid3D()
std::cout << "Number of output vertices " << coordArray.GetNumberOfValues() << std::endl;
std::cout << "Number of output components " << coordArray.GetNumberOfComponents() << std::endl;
vtkm::Bounds bounds = coordinates.GetBounds(DeviceAdapter());
vtkm::Bounds bounds = coordinates.GetBounds();
std::cout << "Bounds " << bounds << std::endl;
// Five tets are created for every hex cell

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

@ -36,8 +36,7 @@ void TestVertexClustering()
vtkm::cont::DataSet dataSet = maker.Make3DExplicitDataSetCowNose();
//compute the bounds before calling the algorithm
vtkm::Bounds bounds =
dataSet.GetCoordinateSystem().GetBounds(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
vtkm::Bounds bounds = dataSet.GetCoordinateSystem().GetBounds();
// run
vtkm::worklet::VertexClustering clustering;