2015-05-20 16:46:00 +00:00
|
|
|
//============================================================================
|
|
|
|
// Copyright (c) Kitware, Inc.
|
|
|
|
// All rights reserved.
|
|
|
|
// See LICENSE.txt for details.
|
2019-04-15 23:24:21 +00:00
|
|
|
//
|
2015-05-20 16:46:00 +00:00
|
|
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
|
|
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
|
// PURPOSE. See the above copyright notice for more information.
|
|
|
|
//============================================================================
|
|
|
|
#ifndef vtk_m_cont_CoordinateSystem_h
|
|
|
|
#define vtk_m_cont_CoordinateSystem_h
|
|
|
|
|
2016-05-26 22:02:30 +00:00
|
|
|
#include <vtkm/Bounds.h>
|
|
|
|
|
2017-12-12 19:26:23 +00:00
|
|
|
#include <vtkm/cont/ArrayHandleCast.h>
|
2019-04-03 18:15:26 +00:00
|
|
|
#include <vtkm/cont/CastAndCall.h>
|
2015-08-17 18:47:46 +00:00
|
|
|
#include <vtkm/cont/Field.h>
|
2020-10-21 14:17:35 +00:00
|
|
|
#include <vtkm/cont/UncertainArrayHandle.h>
|
2015-05-20 16:46:00 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace cont
|
|
|
|
{
|
2020-06-30 21:10:48 +00:00
|
|
|
|
2023-07-27 20:07:19 +00:00
|
|
|
/// @brief Manages a coordinate system for a `DataSet`.
|
|
|
|
///
|
|
|
|
/// A coordinate system is really a field with a special meaning, so `CoordinateSystem`
|
|
|
|
/// class inherits from the `Field` class. `CoordinateSystem` constrains the field to
|
|
|
|
/// be associated with points and typically has 3D floating point vectors for values.
|
2016-12-16 22:04:58 +00:00
|
|
|
class VTKM_CONT_EXPORT CoordinateSystem : public vtkm::cont::Field
|
2015-05-20 16:46:00 +00:00
|
|
|
{
|
2017-08-16 15:34:21 +00:00
|
|
|
using Superclass = vtkm::cont::Field;
|
2015-08-19 04:56:10 +00:00
|
|
|
|
2015-07-12 16:05:47 +00:00
|
|
|
public:
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2018-03-09 19:01:22 +00:00
|
|
|
CoordinateSystem();
|
2016-08-03 18:38:25 +00:00
|
|
|
|
2022-10-31 17:22:37 +00:00
|
|
|
// It's OK for regular _point_ fields to become a CoordinateSystem object.
|
|
|
|
VTKM_CONT CoordinateSystem(const vtkm::cont::Field& src);
|
|
|
|
|
2020-10-21 14:17:35 +00:00
|
|
|
VTKM_CONT CoordinateSystem(std::string name, const vtkm::cont::UnknownArrayHandle& data);
|
2017-12-12 19:26:23 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename T, typename Storage>
|
2020-03-17 23:22:35 +00:00
|
|
|
VTKM_CONT CoordinateSystem(std::string name, const ArrayHandle<T, Storage>& data)
|
2022-03-17 17:02:37 +00:00
|
|
|
: Superclass(name, Association::Points, data)
|
2020-03-17 23:22:35 +00:00
|
|
|
{
|
|
|
|
}
|
2015-05-20 16:46:00 +00:00
|
|
|
|
2015-08-19 04:56:10 +00:00
|
|
|
/// This constructor of coordinate system sets up a regular grid of points.
|
|
|
|
///
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2019-07-31 16:20:38 +00:00
|
|
|
CoordinateSystem(std::string name,
|
|
|
|
vtkm::Id3 dimensions,
|
|
|
|
vtkm::Vec3f origin = vtkm::Vec3f(0.0f, 0.0f, 0.0f),
|
|
|
|
vtkm::Vec3f spacing = vtkm::Vec3f(1.0f, 1.0f, 1.0f));
|
2015-08-19 04:56:10 +00:00
|
|
|
|
2019-03-14 19:46:28 +00:00
|
|
|
VTKM_CONT
|
|
|
|
vtkm::Id GetNumberOfPoints() const { return this->GetNumberOfValues(); }
|
|
|
|
|
2020-10-21 14:17:35 +00:00
|
|
|
VTKM_CONT vtkm::cont::UncertainArrayHandle<vtkm::TypeListFieldVec3, VTKM_DEFAULT_STORAGE_LIST>
|
|
|
|
GetData() const;
|
2015-08-19 04:56:10 +00:00
|
|
|
|
2020-06-30 21:10:48 +00:00
|
|
|
private:
|
2020-07-09 18:56:23 +00:00
|
|
|
#ifdef VTKM_USE_DOUBLE_PRECISION
|
|
|
|
using FloatNonDefault = vtkm::Float32;
|
|
|
|
#else
|
|
|
|
using FloatNonDefault = vtkm::Float64;
|
|
|
|
#endif
|
|
|
|
using Vec3f_nd = vtkm::Vec<FloatNonDefault, 3>;
|
|
|
|
|
|
|
|
struct StorageToArrayDefault
|
2020-06-30 21:10:48 +00:00
|
|
|
{
|
|
|
|
template <typename S>
|
|
|
|
using IsInvalid = vtkm::cont::internal::IsInvalidArrayHandle<vtkm::Vec3f, S>;
|
2015-08-19 04:56:10 +00:00
|
|
|
|
2020-06-30 21:10:48 +00:00
|
|
|
template <typename S>
|
|
|
|
using Transform = vtkm::cont::ArrayHandle<vtkm::Vec3f, S>;
|
|
|
|
};
|
2015-08-19 04:56:10 +00:00
|
|
|
|
2020-07-09 18:56:23 +00:00
|
|
|
struct StorageToArrayNonDefault
|
|
|
|
{
|
|
|
|
template <typename S>
|
|
|
|
using IsInvalid = vtkm::cont::internal::IsInvalidArrayHandle<Vec3f_nd, S>;
|
|
|
|
|
|
|
|
template <typename S>
|
|
|
|
using Transform =
|
|
|
|
vtkm::cont::ArrayHandleCast<vtkm::Vec3f, vtkm::cont::ArrayHandle<Vec3f_nd, S>>;
|
|
|
|
};
|
|
|
|
|
|
|
|
using ArraysFloatDefault = vtkm::ListTransform<
|
|
|
|
vtkm::ListRemoveIf<VTKM_DEFAULT_STORAGE_LIST, StorageToArrayDefault::IsInvalid>,
|
|
|
|
StorageToArrayDefault::Transform>;
|
|
|
|
using ArraysFloatNonDefault = vtkm::ListTransform<
|
|
|
|
vtkm::ListRemoveIf<VTKM_DEFAULT_STORAGE_LIST, StorageToArrayNonDefault::IsInvalid>,
|
|
|
|
StorageToArrayNonDefault::Transform>;
|
|
|
|
|
2020-06-30 21:10:48 +00:00
|
|
|
public:
|
2020-07-09 18:56:23 +00:00
|
|
|
using MultiplexerArrayType = //
|
|
|
|
vtkm::cont::ArrayHandleMultiplexerFromList<
|
|
|
|
vtkm::ListAppend<ArraysFloatDefault, ArraysFloatNonDefault>>;
|
2020-06-30 21:10:48 +00:00
|
|
|
|
|
|
|
/// \brief Returns the data for the coordinate system as an `ArrayHandleMultiplexer`.
|
|
|
|
///
|
|
|
|
/// This array will handle all potential types supported by CoordinateSystem, so all types can be
|
|
|
|
/// handled with one compile pass. However, using this precludes specialization for special
|
|
|
|
/// arrays such as `ArrayHandleUniformPointCoordinates` that could have optimized code paths
|
|
|
|
///
|
|
|
|
VTKM_CONT MultiplexerArrayType GetDataAsMultiplexer() const;
|
2016-01-20 17:04:05 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2020-10-20 19:22:43 +00:00
|
|
|
void GetRange(vtkm::Range* range) const { this->Superclass::GetRange(range); }
|
2017-02-24 21:39:37 +00:00
|
|
|
|
2017-12-12 19:26:23 +00:00
|
|
|
VTKM_CONT
|
2019-03-14 19:46:28 +00:00
|
|
|
vtkm::Vec<vtkm::Range, 3> GetRange() const
|
|
|
|
{
|
|
|
|
vtkm::Vec<vtkm::Range, 3> range;
|
|
|
|
this->GetRange(&range[0]);
|
|
|
|
return range;
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Range> GetRangeAsArrayHandle() const
|
2018-11-06 16:40:39 +00:00
|
|
|
{
|
2020-10-20 19:22:43 +00:00
|
|
|
return this->Superclass::GetRange();
|
2018-11-06 16:40:39 +00:00
|
|
|
}
|
2016-01-20 17:04:05 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2018-11-06 16:40:39 +00:00
|
|
|
vtkm::Bounds GetBounds() const
|
|
|
|
{
|
|
|
|
vtkm::Range ranges[3];
|
|
|
|
this->GetRange(ranges);
|
|
|
|
return vtkm::Bounds(ranges[0], ranges[1], ranges[2]);
|
|
|
|
}
|
2016-05-26 22:02:30 +00:00
|
|
|
|
2024-07-09 19:21:44 +00:00
|
|
|
void PrintSummary(std::ostream& out, bool full = false) const override;
|
2018-05-24 14:36:23 +00:00
|
|
|
|
|
|
|
VTKM_CONT void ReleaseResourcesExecution() override
|
|
|
|
{
|
|
|
|
this->Superclass::ReleaseResourcesExecution();
|
|
|
|
this->GetData().ReleaseResourcesExecution();
|
|
|
|
}
|
2015-05-20 16:46:00 +00:00
|
|
|
};
|
|
|
|
|
2017-11-07 22:43:36 +00:00
|
|
|
template <typename Functor, typename... Args>
|
2017-12-08 16:40:52 +00:00
|
|
|
void CastAndCall(const vtkm::cont::CoordinateSystem& coords, Functor&& f, Args&&... args)
|
2016-08-05 18:47:19 +00:00
|
|
|
{
|
2017-12-12 19:26:23 +00:00
|
|
|
CastAndCall(coords.GetData(), std::forward<Functor>(f), std::forward<Args>(args)...);
|
2016-08-05 18:47:19 +00:00
|
|
|
}
|
|
|
|
|
2017-12-20 22:07:44 +00:00
|
|
|
template <typename T>
|
|
|
|
vtkm::cont::CoordinateSystem make_CoordinateSystem(std::string name,
|
|
|
|
const std::vector<T>& data,
|
|
|
|
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
|
|
|
{
|
|
|
|
return vtkm::cont::CoordinateSystem(name, vtkm::cont::make_ArrayHandle(data, copy));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
vtkm::cont::CoordinateSystem make_CoordinateSystem(std::string name,
|
|
|
|
const T* data,
|
|
|
|
vtkm::Id numberOfValues,
|
|
|
|
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
|
|
|
|
{
|
|
|
|
return vtkm::cont::CoordinateSystem(name,
|
|
|
|
vtkm::cont::make_ArrayHandle(data, numberOfValues, copy));
|
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
namespace internal
|
|
|
|
{
|
2016-08-03 18:38:25 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <>
|
2016-08-03 18:38:25 +00:00
|
|
|
struct DynamicTransformTraits<vtkm::cont::CoordinateSystem>
|
|
|
|
{
|
2017-08-16 15:34:21 +00:00
|
|
|
using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
|
2016-08-03 18:38:25 +00:00
|
|
|
};
|
|
|
|
|
2020-06-30 21:10:48 +00:00
|
|
|
|
2016-08-03 18:38:25 +00:00
|
|
|
} // namespace internal
|
2015-05-20 16:46:00 +00:00
|
|
|
} // namespace cont
|
|
|
|
} // namespace vtkm
|
|
|
|
|
2018-06-18 17:56:38 +00:00
|
|
|
//=============================================================================
|
|
|
|
// Specializations of serialization related classes
|
2019-09-12 21:19:36 +00:00
|
|
|
/// @cond SERIALIZATION
|
2019-02-05 16:02:29 +00:00
|
|
|
namespace mangled_diy_namespace
|
2018-06-18 17:56:38 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
template <>
|
2020-10-21 14:17:35 +00:00
|
|
|
struct Serialization<vtkm::cont::CoordinateSystem> : Serialization<vtkm::cont::Field>
|
2018-06-18 17:56:38 +00:00
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
} // diy
|
2019-09-12 21:19:36 +00:00
|
|
|
/// @endcond SERIALIZATION
|
2018-06-18 17:56:38 +00:00
|
|
|
|
2015-05-29 16:48:31 +00:00
|
|
|
#endif //vtk_m_cont_CoordinateSystem_h
|