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

migrated ContourTreeAugmented filter

Browse Source
This commit is contained in:
Li-Ta Lo 2022-06-27 18:01:42 -06:00
parent 7c1573ea56
commit 7c8dbcde28
230 changed files with 757 additions and 2396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
examples/contour_tree_augmented/ContourTreeApp.cxx
View File

@ -71,11 +71,11 @@
#include <vtkm/cont/Timer.h>
#include <vtkm/io/BOVDataSetReader.h>
#include <vtkm/filter/ContourTreeUniformAugmented.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/ProcessContourTree.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/processcontourtree/Branch.h>
#include <vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ProcessContourTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/processcontourtree/Branch.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
@ -644,7 +644,8 @@ int main(int argc, char* argv[])
prevTime = currTime;
// Convert the mesh of values into contour tree, pairs of vertex ids
vtkm::filter::ContourTreeAugmented filter(useMarchingCubes, computeRegularStructure);
vtkm::filter::scalar_topology::ContourTreeAugmented filter(useMarchingCubes,
computeRegularStructure);
#ifdef WITH_MPI
filter.SetSpatialDecomposition(

3
vtkm/filter/CMakeLists.txt
View File

@ -19,6 +19,7 @@ set(deprecated_headers
ComputeMoments.h
Contour.h
ContourTreeUniform.h
ContourTreeUniformAugmented.h
CoordinateSystemTransform.h
CrossProduct.h
DotProduct.h
@ -100,7 +101,6 @@ set(common_header_template_sources
vtkm_declare_headers(${common_header_template_sources})
set(extra_headers
ContourTreeUniformAugmented.h
ContourTreeUniformDistributed.h
Lagrangian.h
LagrangianStructures.h
@ -112,7 +112,6 @@ set(extra_headers
)
set(extra_header_template_sources
ContourTreeUniformAugmented.hxx
ContourTreeUniformDistributed.hxx
Lagrangian.hxx
LagrangianStructures.hxx

183
vtkm/filter/ContourTreeUniformAugmented.h
View File

@ -7,185 +7,28 @@
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
// Copyright (c) 2018, The Regents of the University of California, through
// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
// from the U.S. Dept. of Energy). All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// (2) Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// (3) Neither the name of the University of California, Lawrence Berkeley National
// Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//
//=============================================================================
//
// This code is an extension of the algorithm presented in the paper:
// Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
// Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
// Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
// (LDAV), October 2016, Baltimore, Maryland.
//
// The PPP2 algorithm and software were jointly developed by
// Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_filter_ContourTreeUniformAugmented_h
#define vtk_m_filter_ContourTreeUniformAugmented_h
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_distributed/MultiBlockContourTreeHelper.h>
#include <vtkm/filter/FilterField.h>
#include <memory>
#include <vtkm/Deprecated.h>
#include <vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h>
namespace vtkm
{
namespace filter
{
/// \brief Construct the Contour Tree for a 2D or 3D regular mesh
///
/// This filter implements the parallel peak pruning algorithm. In contrast to
/// the ContourTreeUniform filter, this filter is optimized to allow for the
/// computation of the augmented contour tree, i.e., the contour tree including
/// all regular mesh vertices. Augmentation with regular vertices is used in
/// practice to compute statistics (e.g., volume), to segment the input mesh,
/// facilitate iso-value selection, enable localization of all verticies of a
/// mesh in the tree among others.
///
/// In addition to single-block computation, the filter also supports multi-block
/// regular grids. The blocks are processed in parallel using DIY and then the
/// tree are merged progressively using a binary-reduction scheme to compute the
/// final contour tree. I.e., in the multi-block context, the final tree is
/// constructed on rank 0.
class ContourTreeAugmented : public vtkm::filter::FilterField<ContourTreeAugmented>
VTKM_DEPRECATED(1.8,
"Use vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h instead of "
"vtkm/filter/ContourTreeUniformAugmented.h.")
inline void ContourTreeUniformAugmented_deprecated() {}
inline void ContourTreeUniformAugmented_deprecated_warning()
{
public:
using SupportedTypes = vtkm::TypeListScalarAll;
///
/// Create the contour tree filter
/// @param[in] useMarchingCubes Boolean indicating whether marching cubes (true) or freudenthal (false)
/// connectivity should be used. Valid only for 3D input data. Default is false.
/// @param[in] computeRegularStructure Unsigned int indicating whether the tree should be augmented.
/// 0=no augmentation, 1=full augmentation, 2=boundary augmentation. The
/// latter option (=2) is mainly relevant for multi-block input data to
/// improve efficiency by considering only boundary vertices during the
/// merging of data blocks.
///
VTKM_CONT
ContourTreeAugmented(bool useMarchingCubes = false, unsigned int computeRegularStructure = 1);
ContourTreeUniformAugmented_deprecated();
}
///
/// Define the spatial decomposition of the data in case we run in parallel with a multi-block dataset
///
/// Note: Only used when running on a multi-block dataset.
/// @param[in] blocksPerDim Number of data blocks used in each data dimension
/// @param[in] globalSize Global extends of the input mesh (i.e., number of mesh points in each dimension)
/// @param[in] localBlockIndices Array with the (x,y,z) index of each local data block with
/// with respect to blocksPerDim
/// @param[in] localBlockOrigins Array with the (x,y,z) origin (with regard to mesh index) of each
/// local data block
/// @param[in] localBlockSizes Array with the sizes (i.e., extends in number of mesh points) of each
/// local data block
VTKM_CONT
void SetSpatialDecomposition(vtkm::Id3 blocksPerDim,
vtkm::Id3 globalSize,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes);
}
} // namespace vtkm::filter
/// Output field "saddlePeak" wich is pairs of vertex ids indicating saddle and peak of contour
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//@{
/// when operating on vtkm::cont::MultiBlock we want to
/// do processing across ranks as well. Just adding pre/post handles
/// for the same does the trick.
template <typename DerivedPolicy>
VTKM_CONT void PreExecute(const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename DerivedPolicy>
VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output,
const vtkm::filter::PolicyBase<DerivedPolicy>&);
///
/// Internal helper function that implements the actual functionality of PostExecute
///
/// In the case we operate on vtkm::cont::MultiBlock we need to merge the trees
/// computed on the block to compute the final contour tree.
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT void DoPostExecute(
const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::cont::ArrayHandle<T, StorageType>&, // dummy parameter to get the type
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//@}
//@{
/// Get the contour tree computed by the filter
const vtkm::worklet::contourtree_augmented::ContourTree& GetContourTree() const;
/// Get the sort order for the mesh vertices
const vtkm::worklet::contourtree_augmented::IdArrayType& GetSortOrder() const;
/// Get the number of iterations used to compute the contour tree
vtkm::Id GetNumIterations() const;
//@}
private:
/// Use marching cubes connectivity for computing the contour tree
bool UseMarchingCubes;
// 0=no augmentation, 1=full augmentation, 2=boundary augmentation
unsigned int ComputeRegularStructure;
// TODO Should the additional fields below be add to the vtkm::filter::ResultField and what is the best way to represent them
// Additional result fields not included in the vtkm::filter::ResultField returned by DoExecute
/// The contour tree computed by the filter
vtkm::worklet::contourtree_augmented::ContourTree ContourTreeData;
/// Number of iterations used to compute the contour tree
vtkm::Id NumIterations;
/// Array with the sorted order of the mesh vertices
vtkm::worklet::contourtree_augmented::IdArrayType MeshSortOrder;
/// Helper object to help with the parallel merge when running with DIY in parallel with MulitBlock data
std::unique_ptr<vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper>
MultiBlockTreeHelper;
};
} // namespace filter
} // namespace vtkm
#include <vtkm/filter/ContourTreeUniformAugmented.hxx>
#endif // vtk_m_filter_ContourTreeUniformAugmented_h
#endif //vtk_m_filter_ContourTreeUniformAugmented_h

4
vtkm/filter/ContourTreeUniformDistributed.h
View File

@ -57,8 +57,8 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_distributed/BoundaryTree.h>
#include <vtkm/worklet/contourtree_distributed/HierarchicalContourTree.h>
#include <vtkm/worklet/contourtree_distributed/InteriorForest.h>

7
vtkm/filter/ContourTreeUniformDistributed.hxx
View File

@ -58,10 +58,9 @@
// single-node augmented contour tree includes
#include <vtkm/filter/ContourTreeUniformDistributed.h>
#include <vtkm/worklet/ContourTreeUniformAugmented.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
// distributed contour tree includes
#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>

2
vtkm/filter/scalar_topology/CMakeLists.txt
View File

@ -9,6 +9,7 @@
##============================================================================
set(scalar_topology_headers
ContourTreeUniform.h
ContourTreeUniformAugmented.h
DistributedBranchDecompositionFilter.h
)
@ -16,6 +17,7 @@ set(scalar_topology_sources
internal/BranchDecompositionBlock.cxx
internal/ComputeDistributedBranchDecompositionFunctor.cxx
ContourTreeUniform.cxx
ContourTreeUniformAugmented.cxx
DistributedBranchDecompositionFilter.cxx
)

217
vtkm/filter/ContourTreeUniformAugmented.hxx → vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
View File

@ -50,15 +50,9 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_filter_ContourTreeUniformAugmented_hxx
#define vtk_m_filter_ContourTreeUniformAugmented_hxx
#include <vtkm/cont/Timer.h>
#include <vtkm/filter/ContourTreeUniformAugmented.h>
#include <vtkm/filter/scalar_topology/internal/SpatialDecomposition.h>
#include <vtkm/worklet/ContourTreeUniformAugmented.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h>
#include <vtkm/filter/scalar_topology/worklet/ContourTreeUniformAugmented.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
@ -76,35 +70,13 @@ namespace vtkm
{
namespace filter
{
namespace detail
namespace scalar_topology
{
//----Helper struct to call DoPostExecute. This is used to be able to
// wrap the PostExecute work in a functor so that we can use VTK-M's
// vtkm::cont::CastAndCall to infer the FieldType template parameters
struct PostExecuteCaller
{
template <typename T, typename S, typename DerivedPolicy>
VTKM_CONT void operator()(const vtkm::cont::ArrayHandle<T, S>&,
ContourTreeAugmented* self,
const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy) const
{
vtkm::cont::ArrayHandle<T, S> dummy;
self->DoPostExecute(input, output, fieldMeta, dummy, policy);
}
};
} // end namespace detail
//-----------------------------------------------------------------------------
ContourTreeAugmented::ContourTreeAugmented(bool useMarchingCubes,
unsigned int computeRegularStructure)
: vtkm::filter::FilterField<ContourTreeAugmented>()
, UseMarchingCubes(useMarchingCubes)
: UseMarchingCubes(useMarchingCubes)
, ComputeRegularStructure(computeRegularStructure)
, MultiBlockTreeHelper(nullptr)
{
@ -123,9 +95,8 @@ void ContourTreeAugmented::SetSpatialDecomposition(
this->MultiBlockTreeHelper.reset();
}
this->MultiBlockTreeHelper =
std::unique_ptr<vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper>(
new vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper(
blocksPerDim, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes));
std::make_unique<vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper>(
blocksPerDim, globalSize, localBlockIndices, localBlockOrigins, localBlockSizes);
}
const vtkm::worklet::contourtree_augmented::ContourTree& ContourTreeAugmented::GetContourTree()
@ -145,28 +116,24 @@ vtkm::Id ContourTreeAugmented::GetNumIterations() const
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
vtkm::cont::DataSet ContourTreeAugmented::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet ContourTreeAugmented::DoExecute(const vtkm::cont::DataSet& input)
{
vtkm::cont::Timer timer;
timer.Start();
// Check that the field is Ok
if (fieldMeta.IsPointField() == false)
const auto& field = this->GetFieldFromDataSet(input);
if (!field.IsFieldPoint())
{
throw vtkm::cont::ErrorFilterExecution("Point field expected.");
}
// Use the GetPointDimensions struct defined in the header to collect the meshSize information
vtkm::worklet::ContourTreeAugmented worklet;
vtkm::Id3 meshSize;
const auto& cells = input.GetCellSet();
vtkm::filter::ApplyPolicyCellSet(cells, policy, *this)
.CastAndCall(vtkm::worklet::contourtree_augmented::GetPointDimensions(), meshSize);
cells.CastAndCallForTypes<VTKM_DEFAULT_CELL_SET_LIST_STRUCTURED>(
vtkm::worklet::contourtree_augmented::GetPointDimensions(), meshSize);
// TODO blockIndex needs to change if we have multiple blocks per MPI rank and DoExecute is called for multiple blocks
std::size_t blockIndex = 0;
@ -184,61 +151,87 @@ vtkm::cont::DataSet ContourTreeAugmented::DoExecute(
}
}
// Run the worklet
worklet.Run(field,
MultiBlockTreeHelper ? MultiBlockTreeHelper->LocalContourTrees[blockIndex]
: this->ContourTreeData,
MultiBlockTreeHelper ? MultiBlockTreeHelper->LocalSortOrders[blockIndex]
: this->MeshSortOrder,
this->NumIterations,
meshSize,
this->UseMarchingCubes,
compRegularStruct);
// Create the result object
vtkm::cont::DataSet result;
// If we run in parallel but with only one global block, then we need set our outputs correctly
// here to match the expected behavior in parallel
if (this->MultiBlockTreeHelper)
{
if (this->MultiBlockTreeHelper->GetGlobalNumberOfBlocks() == 1)
// FIXME: reduce the size of lambda.
auto resolveType = [&](const auto& concrete) {
using T = typename std::decay_t<decltype(concrete)>::ValueType;
vtkm::worklet::ContourTreeAugmented worklet;
// Run the worklet
worklet.Run(concrete,
MultiBlockTreeHelper ? MultiBlockTreeHelper->LocalContourTrees[blockIndex]
: this->ContourTreeData,
MultiBlockTreeHelper ? MultiBlockTreeHelper->LocalSortOrders[blockIndex]
: this->MeshSortOrder,
this->NumIterations,
meshSize,
this->UseMarchingCubes,
compRegularStruct);
// If we run in parallel but with only one global block, then we need set our outputs correctly
// here to match the expected behavior in parallel
if (this->MultiBlockTreeHelper)
{
// Copy the contour tree and mesh sort order to the output
this->ContourTreeData = this->MultiBlockTreeHelper->LocalContourTrees[0];
this->MeshSortOrder = this->MultiBlockTreeHelper->LocalSortOrders[0];
// In parallel we need the sorted values as output resulti
// Construct the sorted values by permutting the input field
auto fieldPermutted = vtkm::cont::make_ArrayHandlePermutation(this->MeshSortOrder, field);
vtkm::cont::ArrayHandle<T> sortedValues;
vtkm::cont::Algorithm::Copy(fieldPermutted, sortedValues);
// Create the result object
vtkm::cont::DataSet result;
vtkm::cont::Field rfield(
this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, sortedValues);
result.AddField(rfield);
return result;
if (this->MultiBlockTreeHelper->GetGlobalNumberOfBlocks() == 1)
{
// Copy the contour tree and mesh sort order to the output
this->ContourTreeData = this->MultiBlockTreeHelper->LocalContourTrees[0];
this->MeshSortOrder = this->MultiBlockTreeHelper->LocalSortOrders[0];
// In parallel we need the sorted values as output resulti
// Construct the sorted values by permutting the input field
auto fieldPermutted =
vtkm::cont::make_ArrayHandlePermutation(this->MeshSortOrder, concrete);
// FIXME: can sortedValues be ArrayHandleUnknown?
vtkm::cont::ArrayHandle<T> sortedValues;
vtkm::cont::Algorithm::Copy(fieldPermutted, sortedValues);
// FIXME: is this the right way to create the DataSet? The original code creates an empty
// DataSet without any coordinate system etc.
result = this->CreateResultField(input,
this->GetOutputFieldName(),
vtkm::cont::Field::Association::WholeMesh,
sortedValues);
// vtkm::cont::Field rfield(
// this->GetOutputFieldName(), vtkm::cont::Field::Association::WholeMesh, sortedValues);
// result.AddField(rfield);
// return result;
}
}
}
else
{
// Construct the expected result for serial execution. Note, in serial the result currently
// not actually being used, but in parallel we need the sorted mesh values as output
// This part is being hit when we run in serial or parallel with more than one rank.
result =
this->CreateResultFieldPoint(input, this->GetOutputFieldName(), ContourTreeData.Arcs);
// return CreateResultFieldPoint(input, ContourTreeData.Arcs, this->GetOutputFieldName());
}
};
this->CastAndCallScalarField(field, resolveType);
VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
std::endl
<< " " << std::setw(38) << std::left << "Contour Tree Filter DoExecute"
<< ": " << timer.GetElapsedTime() << " seconds");
// Construct the expected result for serial execution. Note, in serial the result currently
// not actually being used, but in parallel we need the sorted mesh values as output
// This part is being hit when we run in serial or parallel with more then one rank
return CreateResultFieldPoint(input, ContourTreeData.Arcs, this->GetOutputFieldName());
return result;
} // ContourTreeAugmented::DoExecute
// TODO: is multiblock case ever tested?
VTKM_CONT vtkm::cont::PartitionedDataSet ContourTreeAugmented::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
this->PreExecute(input);
auto result = this->NewFilter::DoExecutePartitions(input);
this->PostExecute(input, result);
return result;
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT void ContourTreeAugmented::PreExecute(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
VTKM_CONT void ContourTreeAugmented::PreExecute(const vtkm::cont::PartitionedDataSet& input)
{
//if( input.GetNumberOfBlocks() != 1){
// throw vtkm::cont::ErrorBadValue("Expected MultiBlock data with 1 block per rank ");
//}
if (this->MultiBlockTreeHelper)
{
if (this->MultiBlockTreeHelper->GetGlobalNumberOfBlocks(input) !=
@ -252,25 +245,14 @@ inline VTKM_CONT void ContourTreeAugmented::PreExecute(
throw vtkm::cont::ErrorFilterExecution(
"Global number of block in MultiBlock dataset does not match the SpatialDecomposition");
}
} //else
//{
// throw vtkm::cont::ErrorFilterExecution("Spatial decomposition not defined for MultiBlock execution. Use ContourTreeAugmented::SetSpatialDecompoistion to define the domain decomposition.");
//}
}
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT void ContourTreeAugmented::DoPostExecute(
const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::cont::ArrayHandle<T, StorageType>&, // dummy parameter to get the type
vtkm::filter::PolicyBase<DerivedPolicy> policy)
template <typename T>
VTKM_CONT void ContourTreeAugmented::DoPostExecute(const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output)
{
(void)fieldMeta; // avoid unused parameter warning
(void)policy; // avoid unused parameter warning
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
vtkm::Id size = comm.size();
vtkm::Id rank = comm.rank();
@ -478,35 +460,30 @@ VTKM_CONT void ContourTreeAugmented::DoPostExecute(
localLinks.clear();
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT void ContourTreeAugmented::PostExecute(
const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& result,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
VTKM_CONT void ContourTreeAugmented::PostExecute(const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& result)
{
if (this->MultiBlockTreeHelper)
{
vtkm::cont::Timer timer;
timer.Start();
// We are running in parallel and need to merge the contour tree in PostExecute
if (MultiBlockTreeHelper->GetGlobalNumberOfBlocks() == 1)
{
return;
}
auto field =
input.GetPartition(0).GetField(this->GetActiveFieldName(), this->GetActiveFieldAssociation());
vtkm::filter::FieldMetadata metaData(field);
vtkm::filter::FilterTraits<ContourTreeAugmented> traits;
vtkm::cont::CastAndCall(vtkm::filter::ApplyPolicyFieldActive(field, policy, traits),
detail::PostExecuteCaller{},
this,
input,
result,
metaData,
policy);
// To infer and pass on the ValueType of the field.
auto PostExecuteCaller = [&](const auto& concrete) {
using T = typename std::decay_t<decltype(concrete)>::ValueType;
this->DoPostExecute<T>(input, result);
};
this->CastAndCallScalarField(field, PostExecuteCaller);
this->MultiBlockTreeHelper.reset();
VTKM_LOG_S(vtkm::cont::LogLevel::Perf,
@ -516,8 +493,6 @@ inline VTKM_CONT void ContourTreeAugmented::PostExecute(
}
}
} // namespace scalar_topology
} // namespace filter
} // namespace vtkm::filter
#endif
} // namespace vtkm

191
vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h Normal file
View File

@ -0,0 +1,191 @@
//============================================================================
// 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 (c) 2018, The Regents of the University of California, through
// Lawrence Berkeley National Laboratory (subject to receipt of any required approvals
// from the U.S. Dept. of Energy). All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// (1) Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// (2) Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// (3) Neither the name of the University of California, Lawrence Berkeley National
// Laboratory, U.S. Dept. of Energy nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//
//=============================================================================
//
// This code is an extension of the algorithm presented in the paper:
// Parallel Peak Pruning for Scalable SMP Contour Tree Computation.
// Hamish Carr, Gunther Weber, Christopher Sewell, and James Ahrens.
// Proceedings of the IEEE Symposium on Large Data Analysis and Visualization
// (LDAV), October 2016, Baltimore, Maryland.
//
// The PPP2 algorithm and software were jointly developed by
// Hamish Carr (University of Leeds), Gunther H. Weber (LBNL), and
// Oliver Ruebel (LBNL)
//==============================================================================
#ifndef vtk_m_filter_scalar_topology_ContourTreeUniformAugmented_h
#define vtk_m_filter_scalar_topology_ContourTreeUniformAugmented_h
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/scalar_topology/vtkm_filter_scalar_topology_export.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_distributed/MultiBlockContourTreeHelper.h>
#include <memory>
namespace vtkm
{
namespace filter
{
namespace scalar_topology
{
/// \brief Construct the Contour Tree for a 2D or 3D regular mesh
///
/// This filter implements the parallel peak pruning algorithm. In contrast to
/// the ContourTreeUniform filter, this filter is optimized to allow for the
/// computation of the augmented contour tree, i.e., the contour tree including
/// all regular mesh vertices. Augmentation with regular vertices is used in
/// practice to compute statistics (e.g., volume), to segment the input mesh,
/// facilitate iso-value selection, enable localization of all verticies of a
/// mesh in the tree among others.
///
/// In addition to single-block computation, the filter also supports multi-block
/// regular grids. The blocks are processed in parallel using DIY and then the
/// tree are merged progressively using a binary-reduction scheme to compute the
/// final contour tree. I.e., in the multi-block context, the final tree is
/// constructed on rank 0.
class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT ContourTreeAugmented : public vtkm::filter::NewFilterField
{
public:
VTKM_CONT bool CanThread() const override
{
// shared helper object MultiBlockTreeHelper.
// TODO: need further investigation.
return false;
}
///
/// Create the contour tree filter
/// @param[in] useMarchingCubes Boolean indicating whether marching cubes (true) or freudenthal (false)
/// connectivity should be used. Valid only for 3D input data. Default is false.
/// @param[in] computeRegularStructure Unsigned int indicating whether the tree should be augmented.
/// 0=no augmentation, 1=full augmentation, 2=boundary augmentation. The
/// latter option (=2) is mainly relevant for multi-block input data to
/// improve efficiency by considering only boundary vertices during the
/// merging of data blocks.
///
VTKM_CONT
explicit ContourTreeAugmented(bool useMarchingCubes = false,
unsigned int computeRegularStructure = 1);
///
/// Define the spatial decomposition of the data in case we run in parallel with a multi-block dataset
///
/// Note: Only used when running on a multi-block dataset.
/// @param[in] blocksPerDim Number of data blocks used in each data dimension
/// @param[in] globalSize Global extends of the input mesh (i.e., number of mesh points in each dimension)
/// @param[in] localBlockIndices Array with the (x,y,z) index of each local data block with
/// with respect to blocksPerDim
/// @param[in] localBlockOrigins Array with the (x,y,z) origin (with regard to mesh index) of each
/// local data block
/// @param[in] localBlockSizes Array with the sizes (i.e., extends in number of mesh points) of each
/// local data block
VTKM_CONT
void SetSpatialDecomposition(vtkm::Id3 blocksPerDim,
vtkm::Id3 globalSize,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockIndices,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockOrigins,
const vtkm::cont::ArrayHandle<vtkm::Id3>& localBlockSizes);
//@{
/// Get the contour tree computed by the filter
const vtkm::worklet::contourtree_augmented::ContourTree& GetContourTree() const;
/// Get the sort order for the mesh vertices
const vtkm::worklet::contourtree_augmented::IdArrayType& GetSortOrder() const;
/// Get the number of iterations used to compute the contour tree
vtkm::Id GetNumIterations() const;
//@}
private:
/// Output field "saddlePeak" wich is pairs of vertex ids indicating saddle and peak of contour
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& inData) override;
//@{
/// when operating on vtkm::cont::MultiBlock we want to
/// do processing across ranks as well. Just adding pre/post handles
/// for the same does the trick.
VTKM_CONT void PreExecute(const vtkm::cont::PartitionedDataSet& input);
VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output);
///
/// Internal helper function that implements the actual functionality of PostExecute
///
/// In the case we operate on vtkm::cont::MultiBlock we need to merge the trees
/// computed on the block to compute the final contour tree.
template <typename T>
VTKM_CONT void DoPostExecute(const vtkm::cont::PartitionedDataSet& input,
vtkm::cont::PartitionedDataSet& output);
//@}
/// Use marching cubes connectivity for computing the contour tree
bool UseMarchingCubes;
// 0=no augmentation, 1=full augmentation, 2=boundary augmentation
unsigned int ComputeRegularStructure;
// TODO Should the additional fields below be add to the vtkm::filter::ResultField and what is the best way to represent them
// Additional result fields not included in the vtkm::filter::ResultField returned by DoExecute
/// The contour tree computed by the filter
vtkm::worklet::contourtree_augmented::ContourTree ContourTreeData;
/// Number of iterations used to compute the contour tree
vtkm::Id NumIterations = 0;
/// Array with the sorted order of the mesh vertices
vtkm::worklet::contourtree_augmented::IdArrayType MeshSortOrder;
/// Helper object to help with the parallel merge when running with DIY in parallel with MulitBlock data
std::unique_ptr<vtkm::worklet::contourtree_distributed::MultiBlockContourTreeHelper>
MultiBlockTreeHelper;
};
} // namespace scalar_topology
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::scalar_topology::ContourTreeAugmented.")
ContourTreeAugmented : public vtkm::filter::scalar_topology::ContourTreeAugmented
{
using scalar_topology::ContourTreeAugmented::ContourTreeAugmented;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_scalar_topology_ContourTreeUniformAugmented_h

2
vtkm/filter/scalar_topology/internal/SpatialDecomposition.h
View File

@ -59,7 +59,7 @@
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/PartitionedDataSet.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE

1
vtkm/filter/scalar_topology/testing/CMakeLists.txt
View File

@ -12,6 +12,7 @@
set(unit_tests
UnitTestContourTreeUniformFilter.cxx
UnitTestContourTreeUniformAugmentedFilter.cxx
UnitTestDistributedBranchDecompositionFilter.cxx
)

34
vtkm/filter/testing/UnitTestContourTreeUniformAugmentedFilter.cxx → vtkm/filter/scalar_topology/testing/UnitTestContourTreeUniformAugmentedFilter.cxx
View File

@ -50,19 +50,11 @@
// Oliver Ruebel (LBNL)
//==============================================================================
#include <vtkm/filter/ContourTreeUniformAugmented.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/ProcessContourTree.h>
#include <utility>
#include <vector>
#include <vtkm/Types.h>
#include <vtkm/filter/scalar_topology/ContourTreeUniformAugmented.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ProcessContourTree.h>
namespace
{
@ -79,9 +71,10 @@ private:
// Internal helper function to execute the contour tree and save repeat code in tests
//
// datSets: 0 -> 5x5.txt (2D), 1 -> 8x9test.txt (2D), 2-> 5b.txt (3D)
vtkm::filter::ContourTreeAugmented RunContourTree(bool useMarchingCubes,
unsigned int computeRegularStructure,
unsigned int dataSetNo) const
vtkm::filter::scalar_topology::ContourTreeAugmented RunContourTree(
bool useMarchingCubes,
unsigned int computeRegularStructure,
unsigned int dataSetNo) const
{
// Create the input uniform cell set with values to contour
vtkm::cont::DataSet dataSet;
@ -102,7 +95,8 @@ private:
default:
VTKM_TEST_ASSERT(false);
}
vtkm::filter::ContourTreeAugmented filter(useMarchingCubes, computeRegularStructure);
vtkm::filter::scalar_topology::ContourTreeAugmented filter(useMarchingCubes,
computeRegularStructure);
filter.SetActiveField("pointvar");
auto result = filter.Execute(dataSet);
return filter;
@ -117,7 +111,7 @@ public:
{
std::cout << "Testing ContourTree_Augmented 2D Mesh. computeRegularStructure="
<< computeRegularStructure << std::endl;
vtkm::filter::ContourTreeAugmented filter =
vtkm::filter::scalar_topology::ContourTreeAugmented filter =
RunContourTree(false, // no marching cubes,
computeRegularStructure, // compute regular structure
0 // use 5x5.txt
@ -164,7 +158,7 @@ public:
{
std::cout << "Testing ContourTree_Augmented 2D Mesh. computeRegularStructure="
<< computeRegularStructure << std::endl;
vtkm::filter::ContourTreeAugmented filter =
vtkm::filter::scalar_topology::ContourTreeAugmented filter =
RunContourTree(false, // no marching cubes,
computeRegularStructure, // compute regular structure
1 // use 8x9test.txt
@ -216,7 +210,7 @@ public:
<< computeRegularStructure << std::endl;
// Execute the filter
vtkm::filter::ContourTreeAugmented filter =
vtkm::filter::scalar_topology::ContourTreeAugmented filter =
RunContourTree(false, // no marching cubes,
computeRegularStructure, // compute regular structure
2 // use 5b.txt (3D) mesh
@ -272,7 +266,7 @@ public:
<< computeRegularStructure << std::endl;
// Execute the filter
vtkm::filter::ContourTreeAugmented filter =
vtkm::filter::scalar_topology::ContourTreeAugmented filter =
RunContourTree(false, // no marching cubes,
computeRegularStructure, // compute regular structure
3 // use 5b.txt (3D) upsampled to 5x6x7 mesh
@ -328,7 +322,7 @@ public:
<< computeRegularStructure << std::endl;
// Execute the filter
vtkm::filter::ContourTreeAugmented filter =
vtkm::filter::scalar_topology::ContourTreeAugmented filter =
RunContourTree(true, // no marching cubes,
computeRegularStructure, // compute regular structure
2 // use 5b.txt (3D) mesh
@ -389,7 +383,7 @@ public:
<< computeRegularStructure << std::endl;
// Execute the filter
vtkm::filter::ContourTreeAugmented filter =
vtkm::filter::scalar_topology::ContourTreeAugmented filter =
RunContourTree(true, // no marching cubes,
computeRegularStructure, // compute regular structure
3 // use 5b.txt (3D) upsampled to 5x6x7 mesh

22
vtkm/worklet/ContourTreeUniformAugmented.h → vtkm/filter/scalar_topology/worklet/ContourTreeUniformAugmented.h
View File

@ -68,17 +68,17 @@
#include <vtkm/worklet/WorkletMapField.h>
// Contour tree worklet includes
#include <vtkm/worklet/contourtree_augmented/ActiveGraph.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_augmented/ContourTreeMaker.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_augmented/MergeTree.h>
#include <vtkm/worklet/contourtree_augmented/MeshExtrema.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary2D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary3D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ActiveGraph.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTreeMaker.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/MergeTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/MeshExtrema.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary2D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
namespace vtkm
{

6
vtkm/filter/scalar_topology/worklet/branch_decomposition/HierarchicalVolumetricBranchDecomposer.h
View File

@ -123,9 +123,6 @@
#include <string>
// Contour tree includes, not yet moved into new filter structure
#include <vtkm/worklet/contourtree_augmented/NotNoSuchElementPredicate.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_distributed/PrintGraph.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_contour_tree/FindRegularByGlobal.h>
#include <vtkm/worklet/contourtree_distributed/hierarchical_contour_tree/FindSuperArcBetweenNodes.h>
@ -137,6 +134,9 @@
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeInitSuperarcListWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/SuperArcVolumetricComparatorIndirectGlobalIdComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/NotNoSuchElementPredicate.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#ifdef DEBUG_PRINT
#define DEBUG_HIERARCHICAL_VOLUMETRIC_BRANCH_DECOMPOSER

2
vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CollapseBranchesPointerDoublingWorklet.h
View File

@ -46,8 +46,8 @@
#ifndef vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_CollapseBranchesPointerDoublingWorklet_h
#define vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_CollapseBranchesPointerDoublingWorklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/CollapseBranchesWorklet.h
View File

@ -46,8 +46,8 @@
#ifndef vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_CollapseBranchesWorklet_h
#define vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_CollapseBranchesWorklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeBestUpDownEdgeWorklet.h
View File

@ -46,8 +46,8 @@
#ifndef vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_LocalBestUpDownByVolumeBestUpDownEdgeWorklet_h
#define vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_LocalBestUpDownByVolumeBestUpDownEdgeWorklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeInitSuperarcListWorklet.h
View File

@ -46,8 +46,8 @@
#ifndef vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_LocalBestUpDownByVolumeInitSuperarcListWorklet_h
#define vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_LocalBestUpDownByVolumeInitSuperarcListWorklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/LocalBestUpDownByVolumeWorklet.h
View File

@ -46,8 +46,8 @@
#ifndef vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_LocalBestUpDownByVolumeWorklet_h
#define vtk_m_filter_scalar_topology_worklet_branch_decomposition_hierarchical_volumetric_branch_decomposer_LocalBestUpDownByVolumeWorklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/filter/scalar_topology/worklet/branch_decomposition/hierarchical_volumetric_branch_decomposer/SuperArcVolumetricComparatorIndirectGlobalIdComparator.h
View File

@ -64,7 +64,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

58
vtkm/worklet/contourtree_augmented/ActiveGraph.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/ActiveGraph.h
View File

@ -57,35 +57,35 @@
#include <numeric>
// local includes
#include <vtkm/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/worklet/contourtree_augmented/MergeTree.h>
#include <vtkm/worklet/contourtree_augmented/MeshExtrema.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/BuildChainsWorklet.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/BuildTrunkWorklet.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/CompactActiveEdgesComputeNewVertexOutdegree.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/CompactActiveEdgesTransferActiveEdges.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/EdgePeakComparator.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/FindGoverningSaddlesWorklet.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/FindSuperAndHyperNodesWorklet.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/HyperArcSuperNodeComparator.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/InitializeActiveEdges.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/InitializeActiveGraphVertices.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/InitializeEdgeFarFromActiveIndices.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/InitializeHyperarcsFromActiveIndices.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/InitializeNeighbourhoodMasksAndOutDegrees.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SetArcsConnectNodes.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SetArcsSetSuperAndHypernodeArcs.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SetArcsSlideVertices.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SetHyperArcsWorklet.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeHyperparents.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeSuperarcs.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SuperArcNodeComparator.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/TransferRegularPointsWorklet.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/TransferSaddleStartsResetEdgeFar.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/TransferSaddleStartsSetNewOutdegreeForSaddles.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/TransferSaddleStartsUpdateEdgeSorter.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/MergeTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/MeshExtrema.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/BuildChainsWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/BuildTrunkWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/CompactActiveEdgesComputeNewVertexOutdegree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/CompactActiveEdgesTransferActiveEdges.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/EdgePeakComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/FindGoverningSaddlesWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/FindSuperAndHyperNodesWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/HyperArcSuperNodeComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeActiveEdges.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeActiveGraphVertices.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeEdgeFarFromActiveIndices.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeHyperarcsFromActiveIndices.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeNeighbourhoodMasksAndOutDegrees.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetArcsConnectNodes.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetArcsSetSuperAndHypernodeArcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetArcsSlideVertices.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetHyperArcsWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeHyperparents.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeSuperarcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SuperArcNodeComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferRegularPointsWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferSaddleStartsResetEdgeFar.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferSaddleStartsSetNewOutdegreeForSaddles.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferSaddleStartsUpdateEdgeSorter.h>
//VTKM includes

2
vtkm/worklet/contourtree_augmented/ArrayTransforms.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/ArrayTransforms.h
View File

@ -62,7 +62,7 @@
#include <vtkm/cont/ArrayHandleTransform.h>
// local includes
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm

0
vtkm/worklet/contourtree_augmented/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/contourtree_augmented/CMakeLists.txt
View File

4
vtkm/worklet/contourtree_augmented/ContourTree.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h
View File

@ -61,8 +61,8 @@
#include <string>
// local includes
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
//VTKM includes
#include <vtkm/Pair.h>

54
vtkm/worklet/contourtree_augmented/ContourTreeMaker.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTreeMaker.h
View File

@ -56,36 +56,36 @@
#include <iomanip>
// local includes
#include <vtkm/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_augmented/MergeTree.h>
#include <vtkm/worklet/contourtree_augmented/MeshExtrema.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/MergeTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/MeshExtrema.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
// contourtree_maker_inc includes
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_InitNewJoinSplitIDAndSuperparents.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_SetAugmentedMergeArcs.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/CompressTrees_Step.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_HypernodesSetFirstSuperchild.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_PermuteArcs.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_ResetHyperparentsId.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetFirstSupernodePerIterationWorklet.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetNewHypernodesAndArcs.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_LocateSuperarcs.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_SetArcs.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ContourTreeNodeComparator.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/ContourTreeSuperNodeComparator.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/FindDegrees_FindRHE.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/FindDegrees_ResetUpAndDowndegree.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/FindDegrees_SubtractLHE.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_CollapsePastRegular.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_InitInAndOutbound.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_TransferToContourTree.h>
#include <vtkm/worklet/contourtree_augmented/contourtreemaker/WasNotTransferred.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_InitNewJoinSplitIDAndSuperparents.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_SetAugmentedMergeArcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/CompressTrees_Step.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_HypernodesSetFirstSuperchild.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_PermuteArcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_ResetHyperparentsId.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetFirstSupernodePerIterationWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetNewHypernodesAndArcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_LocateSuperarcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_SetArcs.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ContourTreeNodeComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ContourTreeSuperNodeComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/FindDegrees_FindRHE.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/FindDegrees_ResetUpAndDowndegree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/FindDegrees_SubtractLHE.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_CollapsePastRegular.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_InitInAndOutbound.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_TransferToContourTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/WasNotTransferred.h>
#include <vtkm/worklet/contourtree_augmented/activegraph/SuperArcNodeComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SuperArcNodeComparator.h>
//VTKM includes

20
vtkm/worklet/contourtree_augmented/DataSetMesh.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h
View File

@ -78,13 +78,13 @@
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/Invoker.h>
#include <vtkm/worklet/contourtree_augmented/NotNoSuchElementPredicate.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/GetOwnedVerticesByGlobalIdWorklet.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/SimulatedSimplicityComperator.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/SortIndices.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/NotNoSuchElementPredicate.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/GetOwnedVerticesByGlobalIdWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/SimulatedSimplicityComperator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/SortIndices.h>
//Define namespace alias for the freudenthal types to make the code a bit more readable
@ -353,8 +353,8 @@ inline void DataSetMesh::DebugPrintValues(const vtkm::cont::ArrayHandle<T, Stora
} // vtkm
// Include specialized mesh classes providing triangulation/connectivity information
#include <vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation2DFreudenthal.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DFreudenthal.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DMarchingCubes.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation2DFreudenthal.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DFreudenthal.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DMarchingCubes.h>
#endif

6
vtkm/worklet/contourtree_augmented/MergeTree.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/MergeTree.h
View File

@ -57,9 +57,9 @@
#include <iomanip>
// local includes
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h>
//VTKM includes

10
vtkm/worklet/contourtree_augmented/MeshExtrema.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/MeshExtrema.h
View File

@ -59,13 +59,13 @@
#include <vtkm/cont/Algorithm.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/Invoker.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/meshextrema/PointerDoubling.h>
#include <vtkm/worklet/contourtree_augmented/meshextrema/SetStarts.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshextrema/PointerDoubling.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshextrema/SetStarts.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/SortIndices.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/SortIndices.h>
namespace mesh_extrema_inc_ns = vtkm::worklet::contourtree_augmented::mesh_extrema_inc;

2
vtkm/worklet/contourtree_augmented/NotNoSuchElementPredicate.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/NotNoSuchElementPredicate.h
View File

@ -54,7 +54,7 @@
#define vtk_m_worklet_contourtree_augmented_not_no_such_element_predicate_h
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

7
vtkm/worklet/contourtree_augmented/PrintVectors.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h
View File

@ -58,15 +58,10 @@
#include <iomanip>
#include <iostream>
#include <string>
#include <vtkm/Pair.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
// local includes
#include <vtkm/cont/arg/Transport.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm

24
vtkm/worklet/contourtree_augmented/ProcessContourTree.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/ProcessContourTree.h
View File

@ -58,14 +58,10 @@
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <vtkm/BinaryOperators.h>
#include <vtkm/BinaryPredicates.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCounting.h>
// local includes
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
//VTKM includes
#include <vtkm/Pair.h>
@ -75,16 +71,16 @@
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleView.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/worklet/contourtree_augmented/processcontourtree/Branch.h>
#include <vtkm/worklet/contourtree_augmented/processcontourtree/SuperArcVolumetricComparator.h>
#include <vtkm/worklet/contourtree_augmented/processcontourtree/SuperNodeBranchComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ContourTree.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/processcontourtree/Branch.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/processcontourtree/SuperArcVolumetricComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/processcontourtree/SuperNodeBranchComparator.h>
#include <vtkm/cont/Invoker.h>
#include <vtkm/worklet/contourtree_augmented/processcontourtree/HypersweepWorklets.h>
#include <vtkm/worklet/contourtree_augmented/processcontourtree/PointerDoubling.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/processcontourtree/HypersweepWorklets.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/processcontourtree/PointerDoubling.h>
//#define DEBUG_PRINT

0
vtkm/worklet/contourtree_augmented/Types.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h
View File

2
vtkm/worklet/contourtree_augmented/activegraph/BuildChainsWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/BuildChainsWorklet.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_build_chains_worklet_h
#define vtk_m_worklet_contourtree_augmented_active_graph_build_chains_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/BuildTrunkWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/BuildTrunkWorklet.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_build_trunk_worklet_h
#define vtk_m_worklet_contourtree_augmented_active_graph_build_trunk_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

39
vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/CMakeLists.txt Normal file
View File

@ -0,0 +1,39 @@
##============================================================================
## 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.
##============================================================================
set(headers
BuildChainsWorklet.h
BuildTrunkWorklet.h
CompactActiveEdgesComputeNewVertexOutdegree.h
CompactActiveEdgesTransferActiveEdges.h
EdgePeakComparator.h
FindGoverningSaddlesWorklet.h
FindSuperAndHyperNodesWorklet.h
HyperArcSuperNodeComparator.h
InitializeActiveEdges.h
InitializeActiveGraphVertices.h
InitializeEdgeFarFromActiveIndices.h
InitializeHyperarcsFromActiveIndices.h
InitializeNeighbourhoodMasksAndOutDegrees.h
SetArcsConnectNodes.h
SetArcsSlideVertices.h
SetArcsSetSuperAndHypernodeArcs.h
SetHyperArcsWorklet.h
SetSuperArcsSetTreeHyperparents.h
SetSuperArcsSetTreeSuperarcs.h
SuperArcNodeComparator.h
TransferRegularPointsWorklet.h
TransferSaddleStartsResetEdgeFar.h
TransferSaddleStartsSetNewOutdegreeForSaddles.h
TransferSaddleStartsUpdateEdgeSorter.h
)
#-----------------------------------------------------------------------------
vtkm_declare_headers(${headers})

2
vtkm/worklet/contourtree_augmented/activegraph/CompactActiveEdgesComputeNewVertexOutdegree.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/CompactActiveEdgesComputeNewVertexOutdegree.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_compact_active_edges_new_vertex_outdegree_h
#define vtk_m_worklet_contourtree_augmented_active_graph_compact_active_edges_new_vertex_outdegree_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/CompactActiveEdgesTransferActiveEdges.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/CompactActiveEdgesTransferActiveEdges.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_compact_active_edges_transfer_active_edges_h
#define vtk_m_worklet_contourtree_augmented_active_graph_compact_active_edges_transfer_active_edges_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/EdgePeakComparator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/EdgePeakComparator.h
View File

@ -55,7 +55,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/FindGoverningSaddlesWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/FindGoverningSaddlesWorklet.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_find_governing_saddles_worklet_h
#define vtk_m_worklet_contourtree_augmented_active_graph_find_governing_saddles_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/FindSuperAndHyperNodesWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/FindSuperAndHyperNodesWorklet.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_find_super_and_hyper_nodes_worklet_h
#define vtk_m_worklet_contourtree_augmented_active_graph_find_super_and_hyper_nodes_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/HyperArcSuperNodeComparator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/HyperArcSuperNodeComparator.h
View File

@ -55,7 +55,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/InitializeActiveEdges.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeActiveEdges.h
View File

@ -54,8 +54,8 @@
#define vtk_m_worklet_contourtree_augmented_active_graph_initialize_active_edges_h
#include <vtkm/exec/arg/BasicArg.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/activegraph/InitializeActiveGraphVertices.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeActiveGraphVertices.h
View File

2
vtkm/worklet/contourtree_augmented/activegraph/InitializeEdgeFarFromActiveIndices.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeEdgeFarFromActiveIndices.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_initialize_edge_far_from_active_indices_h
#define vtk_m_worklet_contourtree_augmented_active_graph_initialize_edge_far_from_active_indices_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/InitializeHyperarcsFromActiveIndices.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeHyperarcsFromActiveIndices.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_initialize_hyperarcs_from_active_indices_h
#define vtk_m_worklet_contourtree_augmented_active_graph_initialize_hyperarcs_from_active_indices_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

0
vtkm/worklet/contourtree_augmented/activegraph/InitializeNeighbourhoodMasksAndOutDegrees.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/InitializeNeighbourhoodMasksAndOutDegrees.h
View File

2
vtkm/worklet/contourtree_augmented/activegraph/SetArcsConnectNodes.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetArcsConnectNodes.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_set_arcs_connect_nodes_h
#define vtk_m_worklet_contourtree_augmented_active_graph_set_arcs_connect_nodes_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/SetArcsSetSuperAndHypernodeArcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetArcsSetSuperAndHypernodeArcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_set_arcs_set_super_and_hypernode_arcs_h
#define vtk_m_worklet_contourtree_augmented_active_graph_set_arcs_set_super_and_hypernode_arcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/SetArcsSlideVertices.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetArcsSlideVertices.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_set_arcs_slide_vertices_h
#define vtk_m_worklet_contourtree_augmented_active_graph_set_arcs_slide_vertices_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/SetHyperArcsWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetHyperArcsWorklet.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_set_hyper_arcs_worklet_h
#define vtk_m_worklet_contourtree_augmented_active_graph_set_hyper_arcs_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeHyperparents.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeHyperparents.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_set_super_arcs_set_tree_hyperparents_h
#define vtk_m_worklet_contourtree_augmented_active_graph_set_super_arcs_set_tree_hyperparents_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeSuperarcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SetSuperArcsSetTreeSuperarcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_set_super_arcs_set_tree_superarcs_h
#define vtk_m_worklet_contourtree_augmented_active_graph_set_super_arcs_set_tree_superarcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/SuperArcNodeComparator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/SuperArcNodeComparator.h
View File

@ -56,7 +56,7 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/activegraph/TransferRegularPointsWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferRegularPointsWorklet.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_transfer_regular_points_worklet_h
#define vtk_m_worklet_contourtree_augmented_active_graph_transfer_regular_points_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/TransferSaddleStartsResetEdgeFar.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferSaddleStartsResetEdgeFar.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_transfer_saddle_starts_reset_edge_far_h
#define vtk_m_worklet_contourtree_augmented_active_graph_transfer_saddle_starts_reset_edge_far_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/TransferSaddleStartsSetNewOutdegreeForSaddles.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferSaddleStartsSetNewOutdegreeForSaddles.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_transfer_saddle_starts_set_new_outdegree_for_saddles_h
#define vtk_m_worklet_contourtree_augmented_active_graph_transfer_saddle_starts_set_new_outdegree_for_saddles_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/activegraph/TransferSaddleStartsUpdateEdgeSorter.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/activegraph/TransferSaddleStartsUpdateEdgeSorter.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_active_graph_transfer_saddle_starts_update_edge_sorter_h
#define vtk_m_worklet_contourtree_augmented_active_graph_transfer_saddle_starts_update_edge_sorter_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm

2
vtkm/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_InitNewJoinSplitIDAndSuperparents.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_InitNewJoinSplitIDAndSuperparents.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_augment_merge_tree_init_new_join_splot_id_and_superparents_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_augment_merge_tree_init_new_join_splot_id_and_superparents_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_SetAugmentedMergeArcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/AugmentMergeTrees_SetAugmentedMergeArcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_augment_merge_tree_set_augmented_merge_arcs_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_augment_merge_tree_set_augmented_merge_arcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/contourtreemaker/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/CMakeLists.txt
View File

2
vtkm/worklet/contourtree_augmented/contourtreemaker/CompressTrees_Step.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/CompressTrees_Step.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compress_trees_step_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compress_trees_step_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_HypernodesSetFirstSuperchild.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_HypernodesSetFirstSuperchild.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_hypernodes_set_first_superchild_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_hypernodes_set_first_superchild_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_PermuteArcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_PermuteArcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_hyper_and_super_structure_permute_arcs_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_hyper_and_super_structure_permute_arcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_ResetHyperparentsId.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_ResetHyperparentsId.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_reset_hyperparents_id_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_reset_hyperparents_id_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetFirstSupernodePerIterationWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetFirstSupernodePerIterationWorklet.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_hyper_and_super_structure_set_first_supernode_per_iteration_worklet_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_hyper_and_super_structure_set_first_supernode_per_iteration_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetNewHypernodesAndArcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeHyperAndSuperStructure_SetNewHypernodesAndArcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_set_new_hyper_nodes_and_arcs_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_set_new_hyper_nodes_and_arcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_LocateSuperarcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_LocateSuperarcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_regular_structure_locate_superarcs_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_regular_structure_locate_superarcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_SetArcs.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ComputeRegularStructure_SetArcs.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_regular_structure_set_arcs_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_compute_regular_structure_set_arcs_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ContourTreeNodeComparator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ContourTreeNodeComparator.h
View File

@ -55,7 +55,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/ContourTreeSuperNodeComparator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/ContourTreeSuperNodeComparator.h
View File

@ -55,7 +55,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/FindDegrees_FindRHE.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/FindDegrees_FindRHE.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_find_degrees_find_rhe_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_find_degrees_find_rhe_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/FindDegrees_ResetUpAndDowndegree.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/FindDegrees_ResetUpAndDowndegree.h
View File

@ -54,8 +54,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_find_degrees_reset_up_and_downdegree_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_find_degrees_reset_up_and_downdegree_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/FindDegrees_SubtractLHE.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/FindDegrees_SubtractLHE.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_find_degrees_subtract_lhe_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_find_degrees_subtract_lhe_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_CollapsePastRegular.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_CollapsePastRegular.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_transfer_leaf_chains_collapse_past_regular_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_transfer_leaf_chains_collapse_past_regular_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_InitInAndOutbound.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_InitInAndOutbound.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_transfer_leaf_chains_init_in_and_outbound_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_transfer_leaf_chains_init_in_and_outbound_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_TransferToContourTree.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/TransferLeafChains_TransferToContourTree.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_transfer_leaf_chains_transfer_to_contour_tree_h
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_transfer_leaf_chains_transfer_to_contour_tree_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/contourtreemaker/WasNotTransferred.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/contourtreemaker/WasNotTransferred.h
View File

@ -54,7 +54,7 @@
#define vtk_m_worklet_contourtree_augmented_contourtree_maker_inc_was_not_transferred_h
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/data_set_mesh/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/CMakeLists.txt
View File

2
vtkm/worklet/contourtree_augmented/data_set_mesh/GetOwnedVerticesByGlobalIdWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/GetOwnedVerticesByGlobalIdWorklet.h
View File

@ -53,8 +53,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_mesh_dem_get_owned_vertices_by_global_id_worklet_h
#define vtk_m_worklet_contourtree_augmented_mesh_dem_get_owned_vertices_by_global_id_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h
View File

@ -64,7 +64,7 @@
#define vtk_m_worklet_contourtree_ppp2_contourtree_mesh_inc_id_relabeler_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure2D.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/MeshStructure2D.h
View File

@ -54,7 +54,7 @@
#define vtk_m_worklet_contourtree_augmented_data_set_mesh_execution_object_mesh_2d_h
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h
View File

0
vtkm/worklet/contourtree_augmented/data_set_mesh/SimulatedSimplicityComperator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/SimulatedSimplicityComperator.h
View File

0
vtkm/worklet/contourtree_augmented/data_set_mesh/SortIndices.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/SortIndices.h
View File

4
vtkm/worklet/contourtree_augmented/meshextrema/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshextrema/CMakeLists.txt
View File

@ -8,8 +8,8 @@
## PURPOSE. See the above copyright notice for more information.
##============================================================================
set(headers
SetStarts.h
PointerDoubling.h
SetStarts.h
PointerDoubling.h
)
#-----------------------------------------------------------------------------

2
vtkm/worklet/contourtree_augmented/meshextrema/PointerDoubling.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshextrema/PointerDoubling.h
View File

@ -54,8 +54,8 @@
#define vtk_m_worklet_contourtree_augmented_pointer_doubling_h
#include <vtkm/exec/ExecutionWholeArray.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/meshextrema/SetStarts.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshextrema/SetStarts.h
View File

22
vtkm/worklet/contourtree_augmented/meshtypes/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/CMakeLists.txt
View File

@ -8,14 +8,14 @@
## PURPOSE. See the above copyright notice for more information.
##============================================================================
set(headers
DataSetMeshTriangulation2DFreudenthal.h
DataSetMeshTriangulation3DFreudenthal.h
DataSetMeshTriangulation3DMarchingCubes.h
ContourTreeMesh.h
MeshStructureFreudenthal2D.h
MeshStructureFreudenthal3D.h
MeshStructureMarchingCubes.h
MeshStructureContourTreeMesh.h
DataSetMeshTriangulation2DFreudenthal.h
DataSetMeshTriangulation3DFreudenthal.h
DataSetMeshTriangulation3DMarchingCubes.h
ContourTreeMesh.h
MeshStructureFreudenthal2D.h
MeshStructureFreudenthal3D.h
MeshStructureMarchingCubes.h
MeshStructureContourTreeMesh.h
)
#----------------------------------------------------------------------------
@ -28,9 +28,9 @@ vtkm_declare_headers(${headers})
#-----------------------------------------------------------------------------
set(extra_headers
freudenthal_2D/Types.h
freudenthal_3D/Types.h
marchingcubes_3D/Types.h
freudenthal_2D/Types.h
freudenthal_3D/Types.h
marchingcubes_3D/Types.h
)
#we do the following to work around a couple of issues.

40
vtkm/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/ContourTreeMesh.h
View File

@ -78,29 +78,29 @@
#include <vtkm/cont/ConvertNumComponentsToOffsets.h>
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h> // This is needed only as an unused default argument.
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/AddToArrayElementsWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ApplyLookupTableDecorator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcValidDecorator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CombinedSimulatedSimplicityIndexComparator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CombinedVectorDifferentFromNext.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyIntoCombinedArrayWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyIntoCombinedNeighborsWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyNeighborsToPackedArray.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/FindDuplicateInOtherWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/GetArcFromDecorator.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/InitToCombinedSortOrderArraysWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/MergeSortedListsWithoutDuplicatesWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ReplaceArcNumWithToVertexWorklet.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundaryContourTreeMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
#include <vtkm/io/ErrorIO.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/contourtree_augmented/ArrayTransforms.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/IdRelabeler.h> // This is needed only as an unused default argument.
#include <vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureContourTreeMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/AddToArrayElementsWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ApplyLookupTableDecorator.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcComparator.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcValidDecorator.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/CombinedSimulatedSimplicityIndexComparator.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/CombinedVectorDifferentFromNext.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyIntoCombinedArrayWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyIntoCombinedNeighborsWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/CopyNeighborsToPackedArray.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/FindDuplicateInOtherWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/GetArcFromDecorator.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/InitToCombinedSortOrderArraysWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/MergeSortedListsWithoutDuplicatesWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ReplaceArcNumWithToVertexWorklet.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundaryContourTreeMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundaryContourTreeMesh.h>
#include <vtkm/worklet/contourtree_augmented/PrintVectors.h> // TODO remove should not be needed
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/PrintVectors.h> // TODO remove should not be needed
#include <vtkm/cont/ExecutionObjectBase.h>

9
vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation2DFreudenthal.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation2DFreudenthal.h
View File

@ -54,12 +54,11 @@
#define vtk_m_worklet_contourtree_augmented_data_set_mesh_triangulation_2d_freudenthal_h
#include <cstdlib>
#include <vtkm/Types.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal2D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundary2D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary2D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal2D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundary2D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary2D.h>
#include <vtkm/cont/ExecutionObjectBase.h>

13
vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DFreudenthal.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DFreudenthal.h
View File

@ -55,16 +55,13 @@
#define vtk_m_worklet_contourtree_augmented_data_set_mesh_triangulation_3d_freudenthal_h
#include <cstdlib>
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleGroupVec.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal3D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/freudenthal_3D/Types.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundary3D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/freudenthal_3D/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundary3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary3D.h>
namespace vtkm
{

14
vtkm/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DMarchingCubes.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/DataSetMeshTriangulation3DMarchingCubes.h
View File

@ -55,16 +55,12 @@
#define vtk_m_worklet_contourtree_augmented_data_set_mesh_triangulation_3d_marchingcubes_h
#include <cstdlib>
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleGroupVec.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureMarchingCubes.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/marchingcubes_3D/Types.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundary3D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/DataSetMesh.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureMarchingCubes.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/marchingcubes_3D/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/ComputeMeshBoundary3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/mesh_boundary/MeshBoundary3D.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureContourTreeMesh.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureContourTreeMesh.h
View File

@ -66,7 +66,7 @@
#include <vtkm/Pair.h>
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>

6
vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal2D.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal2D.h
View File

@ -56,9 +56,9 @@
#include <vtkm/Pair.h>
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure2D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/freudenthal_2D/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/MeshStructure2D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/freudenthal_2D/Types.h>
namespace vtkm

6
vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal3D.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureFreudenthal3D.h
View File

@ -57,9 +57,9 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleGroupVec.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/freudenthal_3D/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/freudenthal_3D/Types.h>
namespace vtkm

6
vtkm/worklet/contourtree_augmented/meshtypes/MeshStructureMarchingCubes.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/MeshStructureMarchingCubes.h
View File

@ -57,9 +57,9 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleGroupVec.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h>
#include <vtkm/worklet/contourtree_augmented/meshtypes/marchingcubes_3D/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/data_set_mesh/MeshStructure3D.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/marchingcubes_3D/Types.h>
namespace vtkm
{

2
vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/AddToArrayElementsWorklet.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/AddToArrayElementsWorklet.h
View File

@ -63,8 +63,8 @@
#ifndef vtk_m_worklet_contourtree_augmented_contourtree_mesh_inc_add_to_array_elements_worklet_h
#define vtk_m_worklet_contourtree_augmented_contourtree_mesh_inc_add_to_array_elements_worklet_h
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ApplyLookupTableDecorator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ApplyLookupTableDecorator.h
View File

2
vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcComparator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcComparator.h
View File

@ -65,7 +65,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/worklet/contourtree_augmented/Types.h>
#include <vtkm/filter/scalar_topology/worklet/contourtree_augmented/Types.h>
namespace vtkm
{

0
vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcValidDecorator.h → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/ArcValidDecorator.h
View File

28
vtkm/worklet/contourtree_augmented/meshtypes/contourtreemesh/CMakeLists.txt → vtkm/filter/scalar_topology/worklet/contourtree_augmented/meshtypes/contourtreemesh/CMakeLists.txt
View File

@ -61,20 +61,20 @@
##==============================================================================
set(headers
AddToArrayElementsWorklet.h
ApplyLookupTableDecorator.h
ArcComparator.h
ArcValidDecorator.h
CombinedSimulatedSimplicityIndexComparator.h
CombinedVectorDifferentFromNext.h
CopyIntoCombinedArrayWorklet.h
CopyIntoCombinedNeighborsWorklet.h
CopyNeighborsToPackedArray.h
FindDuplicateInOtherWorklet.h
GetArcFromDecorator.h
InitToCombinedSortOrderArraysWorklet.h
MergeSortedListsWithoutDuplicatesWorklet.h
ReplaceArcNumWithToVertexWorklet.h
AddToArrayElementsWorklet.h
ApplyLookupTableDecorator.h
ArcComparator.h
ArcValidDecorator.h
CombinedSimulatedSimplicityIndexComparator.h
CombinedVectorDifferentFromNext.h
CopyIntoCombinedArrayWorklet.h
CopyIntoCombinedNeighborsWorklet.h
CopyNeighborsToPackedArray.h
FindDuplicateInOtherWorklet.h
GetArcFromDecorator.h
InitToCombinedSortOrderArraysWorklet.h
MergeSortedListsWithoutDuplicatesWorklet.h
ReplaceArcNumWithToVertexWorklet.h
)
#-----------------------------------------------------------------------------

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