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

migrate Entropy and ND filters

Browse Source
This commit is contained in:
Li-Ta Lo 2022-01-19 07:20:48 -07:00
parent c4a7444b02
commit 271e023354
27 changed files with 303 additions and 558 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
vtkm/filter/CMakeLists.txt
View File

@ -22,7 +22,10 @@ vtkm_add_instantiations(ClipWithImplicitFunctionInstantiations
)
set(deprecated_headers
Entropy.h
Histogram.h
NDEntropy.h
NDHistogram.h
)
vtkm_declare_headers(${deprecated_headers})
@ -84,7 +87,6 @@ set(extra_headers
CreateResult.h
CrossProduct.h
DotProduct.h
Entropy.h
ExternalFaces.h
FieldSelection.h
FieldToColors.h
@ -100,8 +102,6 @@ set(extra_headers
MaskPoints.h
MeshQuality.h
MIRFilter.h
NDEntropy.h
NDHistogram.h
ParticleDensityBase.h
ParticleDensityCloudInCell.h
ParticleDensityNearestGridPoint.h
@ -141,7 +141,6 @@ set(extra_header_template_sources
ComputeMoments.hxx
CoordinateSystemTransform.hxx
CrossProduct.hxx
Entropy.hxx
FieldToColors.hxx
GhostCellClassify.hxx
GhostCellRemove.hxx
@ -153,8 +152,6 @@ set(extra_header_template_sources
Mask.hxx
MeshQuality.hxx
MIRFilter.hxx
NDEntropy.hxx
NDHistogram.hxx
ParticleDensityCloudInCell.hxx
ParticleDensityNearestGridPoint.hxx
ParticleAdvection.hxx

43
vtkm/filter/Entropy.h
View File

@ -7,47 +7,32 @@
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_Entropy_h
#define vtk_m_filter_Entropy_h
#include <vtkm/filter/FilterField.h>
#include <vtkm/Deprecated.h>
#include <vtkm/filter/density_estimate/Entropy.h>
namespace vtkm
{
namespace filter
{
/// \brief Construct the entropy histogram of a given Field
///
/// Construct a histogram which is used to compute the entropy with a default of 10 bins
///
class Entropy : public vtkm::filter::FilterField<Entropy>
VTKM_DEPRECATED(1.8, "Use vtkm/filter/density_estimate/Entropy.h instead of vtkm/filter/Entropy.h.")
inline void Entropy_deprecated() {}
inline void Entropy_deprecated_warning()
{
public:
//currently the Entropy filter only works on scalar data.
using SupportedTypes = TypeListScalarAll;
Entropy_deprecated();
}
//Construct a histogram which is used to compute the entropy with a default of 10 bins
VTKM_CONT
Entropy();
VTKM_CONT
void SetNumberOfBins(vtkm::Id count) { this->NumberOfBins = count; }
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,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
vtkm::Id NumberOfBins;
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::Entropy.") Entropy
: public vtkm::filter::density_estimate::Entropy
{
using density_estimate::Entropy::Entropy;
};
}
} // namespace vtkm::filter
#include <vtkm/filter/Entropy.hxx>
#endif // vtk_m_filter_Entropy_h
#endif //vtk_m_filter_Entropy_h

50
vtkm/filter/Entropy.hxx
View File

@ -1,50 +0,0 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_Entropy_hxx
#define vtk_m_filter_Entropy_hxx
#include <vtkm/worklet/FieldEntropy.h>
namespace vtkm
{
namespace filter
{
//-----------------------------------------------------------------------------
inline VTKM_CONT Entropy::Entropy()
: NumberOfBins(10)
{
this->SetOutputFieldName("entropy");
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Entropy::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&)
{
vtkm::worklet::FieldEntropy worklet;
vtkm::Float64 e = worklet.Run(field, this->NumberOfBins);
//the entropy vector only contain one element, the entorpy of the input field
vtkm::cont::ArrayHandle<vtkm::Float64> entropy;
entropy.Allocate(1);
entropy.WritePortal().Set(0, e);
return CreateResult(inDataSet, entropy, this->GetOutputFieldName(), fieldMetadata);
}
}
} // namespace vtkm::filter
#endif

41
vtkm/filter/NDEntropy.h
View File

@ -10,41 +10,30 @@
#ifndef vtk_m_filter_NDEntropy_h
#define vtk_m_filter_NDEntropy_h
#include <vtkm/filter/FilterDataSet.h>
#include <vtkm/Deprecated.h>
#include <vtkm/filter/density_estimate/NDEntropy.h>
namespace vtkm
{
namespace filter
{
/// \brief Calculate the entropy of input N-Dims fields
///
/// This filter calculate the entropy of input N-Dims fields.
///
class NDEntropy : public vtkm::filter::FilterDataSet<NDEntropy>
VTKM_DEPRECATED(1.8,
"Use vtkm/filter/density_estimate/NDEntropy.h instead of vtkm/filter/NDEntropy.h.")
inline void NDEntropy_deprecated() {}
inline void NDEntropy_deprecated_warning()
{
public:
VTKM_CONT
NDEntropy();
NDEntropy_deprecated();
}
VTKM_CONT
void AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins);
template <typename Policy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
std::vector<vtkm::Id> NumOfBins;
std::vector<std::string> FieldNames;
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::NDEntropy.") NDEntropy
: public vtkm::filter::density_estimate::NDEntropy
{
using density_estimate::NDEntropy::NDEntropy;
};
}
} // namespace vtkm::filter
#include <vtkm/filter/NDEntropy.hxx>
#endif //vtk_m_filter_NDEntropy_h

62
vtkm/filter/NDHistogram.h
View File

@ -10,61 +10,31 @@
#ifndef vtk_m_filter_NDHistogram_h
#define vtk_m_filter_NDHistogram_h
#include <vtkm/filter/FilterDataSet.h>
#include <vtkm/Deprecated.h>
#include <vtkm/filter/density_estimate/NDHistogram.h>
namespace vtkm
{
namespace filter
{
/// \brief Generate a N-Dims histogram from input fields
///
/// This filter takes a data set and with target fields and bins defined,
/// it would generate a N-Dims histogram from input fields. The result is stored
/// in a field named as "Frequency". This filed contains all the frequencies of
/// the N-Dims histogram in sparse representation. That being said, the result
/// field does not store 0 frequency bins. Meanwhile all input fields now
/// would have the same length and store bin ids instead.
/// E.g. (FieldA[i], FieldB[i], FieldC[i], Frequency[i]) is a bin in the histogram.
/// The first three numbers are binIDs for FieldA, FieldB and FieldC. Frequency[i] stores
/// the frequency for this bin (FieldA[i], FieldB[i], FieldC[i]).
///
class NDHistogram : public vtkm::filter::FilterDataSet<NDHistogram>
VTKM_DEPRECATED(
1.8,
"Use vtkm/filter/density_estimate/NDHistogram.h instead of vtkm/filter/NDHistogram.h.")
inline void NDHistogram_deprecated() {}
inline void NDHistogram_deprecated_warning()
{
public:
VTKM_CONT
NDHistogram();
NDHistogram_deprecated();
}
VTKM_CONT
void AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins);
template <typename Policy>
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy);
// This index is the field position in FieldNames
// (or the input _fieldName string vector of SetFields() Function)
VTKM_CONT
vtkm::Float64 GetBinDelta(size_t fieldIdx);
// This index is the field position in FieldNames
// (or the input _fieldName string vector of SetFields() Function)
VTKM_CONT
vtkm::Range GetDataRange(size_t fieldIdx);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private:
std::vector<vtkm::Id> NumOfBins;
std::vector<std::string> FieldNames;
std::vector<vtkm::Float64> BinDeltas;
std::vector<vtkm::Range> DataRanges; //Min Max of the field
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::NDHistogram.") NDHistogram
: public vtkm::filter::density_estimate::NDHistogram
{
using density_estimate::NDHistogram::NDHistogram;
};
}
} // namespace vtkm::filter
#include <vtkm/filter/NDHistogram.hxx>
#endif //vtk_m_filter_NDHistogram_h

12
vtkm/filter/density_estimate/CMakeLists.txt
View File

@ -8,9 +8,17 @@
## PURPOSE. See the above copyright notice for more information.
##============================================================================
set(density_estimate_headers
Histogram.h)
Entropy.h
Histogram.h
NDEntropy.h
NDHistogram.h
)
set(density_estimate_sources_device
Histogram.cxx)
Entropy.cxx
Histogram.cxx
NDEntropy.cxx
NDHistogram.cxx)
vtkm_library(
NAME vtkm_filter_density_estimate

55
vtkm/filter/density_estimate/Entropy.cxx Normal file
View File

@ -0,0 +1,55 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/filter/CreateResult.h>
#include <vtkm/filter/density_estimate/Entropy.h>
#include <vtkm/filter/density_estimate/worklet/FieldEntropy.h>
namespace vtkm
{
namespace filter
{
namespace density_estimate
{
//-----------------------------------------------------------------------------
VTKM_CONT Entropy::Entropy()
{
this->SetOutputFieldName("entropy");
}
//-----------------------------------------------------------------------------
VTKM_CONT vtkm::cont::DataSet Entropy::DoExecute(const vtkm::cont::DataSet& inDataSet)
{
vtkm::worklet::FieldEntropy worklet;
vtkm::Float64 e = 0;
auto resolveType = [&](const auto& concrete) { e = worklet.Run(concrete, this->NumberOfBins); };
const auto& fieldArray = this->GetFieldFromDataSet(inDataSet).GetData();
fieldArray
.CastAndCallForTypesWithFloatFallback<vtkm::TypeListScalarAll, VTKM_DEFAULT_STORAGE_LIST>(
resolveType);
//the entropy vector only contain one element, the entorpy of the input field
vtkm::cont::ArrayHandle<vtkm::Float64> entropy;
entropy.Allocate(1);
entropy.WritePortal().Set(0, e);
auto result = CreateResult(inDataSet,
vtkm::cont::Field{ this->GetOutputFieldName(),
vtkm::cont::Field::Association::WHOLE_MESH,
entropy });
this->MapFieldsOntoOutput(inDataSet, result);
return result;
}
} // namespace density_estimate
} // namespace filter
} // namespace vtkm

51
vtkm/filter/density_estimate/Entropy.h Normal file
View File

@ -0,0 +1,51 @@
//============================================================================
// 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.
//============================================================================
#ifndef vtk_m_filter_density_estimate_Entropy_h
#define vtk_m_filter_density_estimate_Entropy_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
{
namespace filter
{
namespace density_estimate
{
/// \brief Construct the entropy histogram of a given Field
///
/// Construct a histogram which is used to compute the entropy with a default of 10 bins
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT Entropy : public vtkm::filter::NewFilterField
{
public:
//currently the Entropy filter only works on scalar data.
using SupportedTypes = TypeListScalarAll;
//Construct a histogram which is used to compute the entropy with a default of 10 bins
VTKM_CONT
Entropy();
VTKM_CONT
void SetNumberOfBins(vtkm::Id count) { this->NumberOfBins = count; }
VTKM_CONT
vtkm::Id GetNumberOfBins() const { return this->NumberOfBins; }
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
vtkm::Id NumberOfBins = 10;
};
} // namespace density_estimate
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_density_estimate_Entropy_h

2
vtkm/filter/density_estimate/Histogram.h
View File

@ -27,8 +27,6 @@ namespace density_estimate
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT Histogram : public vtkm::filter::NewFilterField
{
public:
using SupportedTypes = vtkm::TypeListScalarAll;
//Construct a histogram with a default of 10 bins
VTKM_CONT
Histogram();

32
vtkm/filter/NDEntropy.hxx → vtkm/filter/density_estimate/NDEntropy.cxx
View File

@ -7,29 +7,22 @@
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_NDEntropy_hxx
#define vtk_m_filter_NDEntropy_hxx
#include <vtkm/cont/DataSet.h>
#include <vtkm/worklet/NDimsEntropy.h>
#include <vtkm/filter/density_estimate/NDEntropy.h>
#include <vtkm/filter/density_estimate/worklet/NDimsEntropy.h>
namespace vtkm
{
namespace filter
{
inline VTKM_CONT NDEntropy::NDEntropy() {}
namespace density_estimate
{
void NDEntropy::AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins)
{
this->FieldNames.push_back(fieldName);
this->NumOfBins.push_back(numOfBins);
}
template <typename Policy>
inline VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> vtkmNotUsed(policy))
VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(const vtkm::cont::DataSet& inData)
{
vtkm::worklet::NDimsEntropy ndEntropy;
ndEntropy.SetNumOfDataPoints(inData.GetField(0).GetNumberOfValues());
@ -53,15 +46,6 @@ inline VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(
outputData.AddField(vtkm::cont::make_FieldPoint("Entropy", entropyHandle));
return outputData;
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT bool NDEntropy::MapFieldOntoOutput(vtkm::cont::DataSet&,
const vtkm::cont::Field&,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}
}
}
#endif
} // namespace density_estimate
} // namespace filter
} // namespace vtkm

42
vtkm/filter/density_estimate/NDEntropy.h Normal file
View File

@ -0,0 +1,42 @@
//============================================================================
// 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.
//============================================================================
#ifndef vtk_m_filter_density_estimate_NDEntropy_h
#define vtk_m_filter_density_estimate_NDEntropy_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
{
namespace filter
{
namespace density_estimate
{
/// \brief Calculate the entropy of input N-Dims fields
///
/// This filter calculate the entropy of input N-Dims fields.
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT NDEntropy : public vtkm::filter::NewFilterField
{
public:
VTKM_CONT
void AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins);
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
std::vector<vtkm::Id> NumOfBins;
std::vector<std::string> FieldNames;
};
}
}
} // namespace vtkm::filter
#endif //vtk_m_filter_density_estimate_NDEntropy_h

36
vtkm/filter/NDHistogram.hxx → vtkm/filter/density_estimate/NDHistogram.cxx
View File

@ -7,20 +7,17 @@
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_NDHistogram_hxx
#define vtk_m_filter_NDHistogram_hxx
#include <vector>
#include <vtkm/cont/DataSet.h>
#include <vtkm/worklet/NDimsHistogram.h>
#include <vtkm/filter/density_estimate/NDHistogram.h>
#include <vtkm/filter/density_estimate/worklet/NDimsHistogram.h>
namespace vtkm
{
namespace filter
{
inline VTKM_CONT NDHistogram::NDHistogram() {}
namespace density_estimate
{
void NDHistogram::AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins)
{
this->FieldNames.push_back(fieldName);
@ -37,9 +34,7 @@ vtkm::Range NDHistogram::GetDataRange(size_t fieldIdx)
return DataRanges[fieldIdx];
}
template <typename Policy>
inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy)
VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::DataSet& inData)
{
vtkm::worklet::NDimsHistogram ndHistogram;
@ -53,10 +48,7 @@ inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::Da
vtkm::Range rangeField;
vtkm::Float64 deltaField;
ndHistogram.AddField(
vtkm::filter::ApplyPolicyFieldNotActive(inData.GetField(this->FieldNames[i]), policy),
this->NumOfBins[i],
rangeField,
deltaField);
inData.GetField(this->FieldNames[i]).GetData(), this->NumOfBins[i], rangeField, deltaField);
DataRanges.push_back(rangeField);
BinDeltas.push_back(deltaField);
}
@ -75,14 +67,6 @@ inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::Da
return outputData;
}
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT bool NDHistogram::MapFieldOntoOutput(vtkm::cont::DataSet&,
const vtkm::cont::Field&,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return false;
}
}
}
#endif
} // namespace density_estimate
} // namespace filter
} // namespace vtkm

62
vtkm/filter/density_estimate/NDHistogram.h Normal file
View File

@ -0,0 +1,62 @@
//============================================================================
// 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.
//============================================================================
#ifndef vtk_m_filter_density_estimate_NDHistogram_h
#define vtk_m_filter_density_estimate_NDHistogram_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
{
namespace filter
{
namespace density_estimate
{
/// \brief Generate a N-Dims histogram from input fields
///
/// This filter takes a data set and with target fields and bins defined,
/// it would generate a N-Dims histogram from input fields. The result is stored
/// in a field named as "Frequency". This filed contains all the frequencies of
/// the N-Dims histogram in sparse representation. That being said, the result
/// field does not store 0 frequency bins. Meanwhile all input fields now
/// would have the same length and store bin ids instead.
/// E.g. (FieldA[i], FieldB[i], FieldC[i], Frequency[i]) is a bin in the histogram.
/// The first three numbers are binIDs for FieldA, FieldB and FieldC. Frequency[i] stores
/// the frequency for this bin (FieldA[i], FieldB[i], FieldC[i]).
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT NDHistogram : public vtkm::filter::NewFilterField
{
public:
VTKM_CONT
void AddFieldAndBin(const std::string& fieldName, vtkm::Id numOfBins);
// This index is the field position in FieldNames
// (or the input _fieldName string vector of SetFields() Function)
VTKM_CONT
vtkm::Float64 GetBinDelta(size_t fieldIdx);
// This index is the field position in FieldNames
// (or the input _fieldName string vector of SetFields() Function)
VTKM_CONT
vtkm::Range GetDataRange(size_t fieldIdx);
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
std::vector<vtkm::Id> NumOfBins;
std::vector<std::string> FieldNames;
std::vector<vtkm::Float64> BinDeltas;
std::vector<vtkm::Range> DataRanges; //Min Max of the field
};
} // namespace density_estimate
} // namespace filter
} // namespace vtm
#endif //vtk_m_filter_density_estimate_NDHistogram_h

6
vtkm/filter/density_estimate/testing/CMakeLists.txt
View File

@ -9,11 +9,15 @@
##============================================================================
set(unit_tests
UnitTestEntropyFilter.cxx
UnitTestHistogramFilter.cxx
UnitTestNDEntropyFilter.cxx
UnitTestNDHistogramFilter.cxx
UnitTestPartitionedDataSetHistogramFilter.cxx)
set(libraries
vtkm_filter_density_estimate)
vtkm_filter_density_estimate
vtkm_source)
vtkm_unit_tests(
SOURCES ${unit_tests}

4
vtkm/filter/testing/UnitTestEntropyFilter.cxx → vtkm/filter/density_estimate/testing/UnitTestEntropyFilter.cxx
View File

@ -8,7 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/Entropy.h>
#include <vtkm/filter/density_estimate/Entropy.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/testing/Testing.h>
@ -24,7 +24,7 @@ void TestEntropy()
vtkm::source::Tangle tangle(dims);
vtkm::cont::DataSet dataSet = tangle.Execute();
vtkm::filter::Entropy entropyFilter;
vtkm::filter::density_estimate::Entropy entropyFilter;
///// calculate entropy of "tangle" field of the data set /////
entropyFilter.SetNumberOfBins(50); //set number of bins

4
vtkm/filter/testing/UnitTestNDEntropyFilter.cxx → vtkm/filter/density_estimate/testing/UnitTestNDEntropyFilter.cxx
View File

@ -8,7 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/NDEntropy.h>
#include <vtkm/filter/density_estimate/NDEntropy.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
@ -177,7 +177,7 @@ void RunTest()
{
vtkm::cont::DataSet ds = MakeTestDataSet();
vtkm::filter::NDEntropy ndEntropyFilter;
vtkm::filter::density_estimate::NDEntropy ndEntropyFilter;
ndEntropyFilter.AddFieldAndBin("fieldA", 10);
ndEntropyFilter.AddFieldAndBin("fieldB", 10);

6
vtkm/filter/testing/UnitTestNDHistogramFilter.cxx → vtkm/filter/density_estimate/testing/UnitTestNDHistogramFilter.cxx
View File

@ -8,10 +8,8 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/NDHistogram.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/density_estimate/NDHistogram.h>
namespace
{
@ -60,7 +58,7 @@ void RunTest()
{
vtkm::cont::DataSet ds = MakeTestDataSet();
vtkm::filter::NDHistogram ndHistFilter;
vtkm::filter::density_estimate::NDHistogram ndHistFilter;
ndHistFilter.AddFieldAndBin("fieldA", 4);
ndHistFilter.AddFieldAndBin("fieldB", 4);

5
vtkm/filter/density_estimate/worklet/CMakeLists.txt
View File

@ -9,6 +9,9 @@
##============================================================================
set(headers
FieldHistogram.h)
FieldEntropy.h
FieldHistogram.h
NDimsEntropy.h
NDimsHistogram.h)
vtkm_declare_headers(${headers})

0
vtkm/worklet/FieldEntropy.h → vtkm/filter/density_estimate/worklet/FieldEntropy.h
View File

2
vtkm/worklet/NDimsEntropy.h → vtkm/filter/density_estimate/worklet/NDimsEntropy.h
View File

@ -15,8 +15,8 @@
#include <vtkm/cont/Algorithm.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/filter/density_estimate/worklet/NDimsHistogram.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/NDimsHistogram.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/histogram/ComputeNDEntropy.h>

0
vtkm/worklet/NDimsHistogram.h → vtkm/filter/density_estimate/worklet/NDimsHistogram.h
View File

3
vtkm/filter/testing/CMakeLists.txt
View File

@ -25,7 +25,6 @@ set(unit_tests
UnitTestContourTreeUniformDistributedFilter.cxx
UnitTestCoordinateSystemTransform.cxx
UnitTestCrossProductFilter.cxx
UnitTestEntropyFilter.cxx
UnitTestExtractGeometryFilter.cxx
UnitTestExtractStructuredFilter.cxx
UnitTestFieldMetadata.cxx
@ -46,8 +45,6 @@ set(unit_tests
UnitTestMeshQualityFilter.cxx
UnitTestMIRFilter.cxx
UnitTestMultiBlockFilter.cxx
UnitTestNDEntropyFilter.cxx
UnitTestNDHistogramFilter.cxx
UnitTestParticleDensity.cxx
UnitTestPartitionedDataSetFilters.cxx
UnitTestPointAverageFilter.cxx

4
vtkm/worklet/CMakeLists.txt
View File

@ -29,8 +29,6 @@ set(headers
DotProduct.h
ExtractGeometry.h
ExtractStructured.h
FieldEntropy.h
../filter/density_estimate/worklet/FieldHistogram.h
FieldStatistics.h
Gradient.h
ImageDifference.h
@ -46,9 +44,7 @@ set(headers
MaskSelect.h
MeshQuality.h
MIR.h
NDimsEntropy.h
NDimsHistMarginalization.h
NDimsHistogram.h
Normalize.h
OrientCellNormals.h
OrientNormals.h

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

@ -44,8 +44,6 @@ set(unit_tests
UnitTestMaskIndices.cxx
UnitTestMaskSelect.cxx
UnitTestNormalize.cxx
UnitTestNDimsEntropy.cxx
UnitTestNDimsHistogram.cxx
UnitTestNDimsHistMarginalization.cxx
UnitTestOrientNormals.cxx
UnitTestParticleAdvection.cxx

205
vtkm/worklet/testing/UnitTestNDimsEntropy.cxx
View File

@ -1,205 +0,0 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/worklet/NDimsEntropy.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/testing/Testing.h>
namespace
{
// Make testing dataset with three fields(variables), each one has 1000 values
vtkm::cont::DataSet MakeTestDataSet()
{
vtkm::cont::DataSet dataSet;
const int xVerts = 20;
const int yVerts = 50;
const int nVerts = xVerts * yVerts;
vtkm::Float32 fieldA[nVerts] = {
8, 10, 9, 8, 14, 11, 12, 9, 19, 7, 8, 11, 7, 10, 11, 11, 11, 6, 8, 8, 7, 15, 9, 7,
8, 10, 9, 10, 10, 12, 7, 6, 14, 10, 14, 10, 7, 11, 13, 9, 13, 11, 10, 10, 12, 12, 7, 12,
10, 11, 12, 8, 13, 9, 5, 12, 11, 9, 5, 9, 12, 9, 6, 10, 11, 9, 9, 11, 9, 7, 7, 18,
16, 13, 12, 8, 10, 11, 9, 8, 17, 3, 15, 15, 9, 10, 10, 8, 10, 9, 7, 9, 8, 10, 13, 9,
7, 11, 7, 10, 13, 10, 11, 9, 10, 7, 10, 6, 12, 6, 9, 7, 6, 12, 12, 9, 12, 12, 11, 6,
1, 12, 8, 13, 14, 8, 8, 10, 7, 7, 6, 7, 5, 11, 6, 11, 13, 8, 13, 5, 9, 12, 7, 11,
10, 15, 11, 9, 7, 12, 15, 7, 8, 7, 12, 8, 21, 16, 13, 11, 10, 14, 12, 11, 12, 14, 7, 11,
7, 12, 16, 8, 10, 8, 9, 7, 8, 7, 13, 13, 11, 15, 7, 7, 6, 11, 7, 12, 12, 13, 14, 11,
13, 11, 11, 9, 15, 8, 6, 11, 12, 10, 11, 7, 6, 14, 11, 10, 12, 5, 8, 9, 11, 15, 11, 10,
17, 14, 9, 10, 10, 12, 11, 13, 13, 12, 11, 7, 8, 10, 7, 11, 10, 5, 8, 10, 13, 13, 12, 6,
10, 7, 13, 8, 11, 7, 10, 7, 8, 7, 14, 16, 9, 11, 8, 11, 9, 15, 11, 10, 10, 12, 7, 7,
11, 7, 5, 17, 9, 11, 11, 11, 10, 17, 10, 15, 7, 11, 12, 16, 9, 8, 11, 14, 9, 22, 8, 8,
8, 13, 12, 12, 1, 14, 15, 6, 15, 8, 11, 16, 14, 8, 6, 9, 8, 9, 9, 10, 8, 6, 13, 8,
6, 12, 11, 12, 13, 8, 6, 6, 5, 6, 10, 9, 11, 12, 14, 12, 10, 11, 10, 10, 8, 13, 8, 11,
7, 13, 13, 12, 12, 13, 15, 4, 9, 16, 7, 9, 8, 10, 6, 9, 11, 12, 6, 7, 14, 6, 4, 15,
5, 18, 9, 9, 11, 12, 9, 5, 6, 7, 15, 6, 11, 14, 8, 12, 6, 9, 5, 9, 14, 9, 12, 6,
9, 14, 11, 12, 12, 13, 15, 9, 8, 7, 13, 12, 7, 13, 6, 9, 10, 10, 10, 9, 11, 5, 9, 13,
16, 9, 10, 8, 9, 6, 13, 12, 8, 12, 9, 12, 17, 8, 11, 10, 8, 7, 11, 7, 13, 13, 10, 14,
11, 9, 6, 6, 14, 16, 5, 9, 13, 11, 12, 7, 4, 6, 9, 11, 11, 10, 12, 9, 7, 13, 8, 8,
12, 5, 10, 7, 11, 11, 10, 10, 14, 6, 8, 8, 3, 12, 16, 11, 11, 7, 6, 12, 11, 5, 9, 12,
9, 13, 7, 8, 9, 9, 12, 7, 9, 8, 12, 11, 6, 10, 6, 7, 6, 11, 10, 8, 9, 8, 4, 19,
12, 6, 10, 9, 6, 12, 9, 14, 7, 8, 11, 7, 7, 12, 13, 9, 13, 12, 8, 6, 10, 17, 19, 10,
10, 13, 5, 11, 8, 10, 8, 16, 12, 6, 6, 7, 10, 9, 12, 8, 5, 10, 7, 18, 9, 12, 10, 4,
9, 9, 15, 15, 6, 7, 7, 11, 12, 4, 8, 18, 5, 12, 12, 11, 10, 14, 9, 9, 10, 8, 10, 8,
10, 9, 9, 4, 10, 12, 5, 13, 6, 9, 7, 5, 12, 8, 11, 10, 9, 17, 9, 9, 8, 11, 18, 11,
10, 9, 4, 13, 10, 15, 5, 10, 9, 7, 7, 8, 10, 6, 6, 19, 10, 16, 7, 7, 9, 10, 10, 13,
10, 10, 14, 13, 12, 8, 7, 13, 12, 11, 13, 12, 9, 8, 6, 8, 10, 3, 8, 8, 12, 12, 13, 13,
10, 5, 10, 7, 13, 7, 9, 5, 13, 7, 10, 8, 13, 11, 17, 9, 6, 14, 10, 10, 13, 9, 15, 8,
15, 9, 12, 11, 12, 8, 3, 9, 8, 10, 12, 8, 14, 13, 12, 11, 12, 9, 18, 10, 13, 7, 4, 4,
11, 8, 3, 7, 9, 10, 12, 7, 11, 21, 9, 7, 8, 9, 10, 10, 11, 9, 15, 13, 21, 12, 8, 11,
9, 10, 11, 9, 17, 8, 9, 8, 14, 6, 13, 9, 8, 11, 12, 12, 12, 11, 6, 13, 7, 9, 11, 15,
17, 17, 11, 10, 7, 8, 11, 8, 6, 9, 13, 7, 9, 6, 5, 10, 7, 16, 16, 9, 7, 6, 14, 8,
13, 16, 7, 7, 10, 11, 6, 10, 9, 9, 8, 14, 11, 9, 11, 9, 10, 11, 9, 8, 14, 11, 7, 12,
11, 8, 9, 9, 10, 11, 11, 10, 9, 6, 6, 11, 16, 10, 7, 6, 6, 13, 18, 8, 12, 11, 14, 13,
8, 8, 10, 17, 17, 6, 6, 10, 18, 5, 8, 11, 6, 6, 14, 10, 9, 6, 11, 6, 13, 12, 10, 6,
9, 9, 9, 13, 7, 17, 10, 14, 10, 9, 10, 10, 11, 10, 11, 15, 13, 6, 12, 19, 10, 12, 12, 15,
13, 10, 10, 13, 11, 13, 13, 17, 6, 5, 6, 7, 6, 9, 13, 11, 8, 12, 9, 6, 10, 16, 11, 12,
5, 12, 14, 13, 13, 16, 11, 6, 12, 12, 15, 8, 7, 11, 8, 5, 10, 8, 9, 11, 9, 12, 10, 5,
12, 11, 9, 6, 14, 12, 10, 11, 9, 6, 7, 12, 8, 12, 8, 15, 9, 8, 7, 9, 3, 6, 14, 7,
8, 11, 9, 10, 12, 9, 10, 9, 8, 6, 12, 11, 6, 8, 9, 8, 15, 11, 7, 18, 12, 11, 10, 13,
11, 11, 10, 7, 9, 8, 8, 11, 11, 13, 6, 12, 13, 16, 11, 11, 5, 12, 14, 15, 9, 14, 15, 6,
8, 7, 6, 8, 9, 19, 7, 12, 11, 8, 14, 12, 10, 9, 3, 7
};
vtkm::Float32 fieldB[nVerts] = {
24, 19, 28, 19, 25, 28, 25, 22, 27, 26, 35, 26, 30, 28, 24, 23, 21, 31, 20, 11, 21, 22, 14, 25,
20, 24, 24, 21, 24, 29, 26, 21, 32, 29, 23, 28, 31, 25, 23, 30, 18, 24, 22, 25, 33, 24, 22, 23,
21, 17, 20, 28, 30, 18, 20, 32, 25, 24, 32, 15, 27, 24, 27, 19, 30, 27, 17, 24, 29, 23, 22, 19,
24, 19, 28, 24, 25, 24, 25, 30, 24, 31, 30, 27, 25, 25, 25, 15, 29, 23, 29, 29, 21, 25, 35, 24,
28, 10, 31, 23, 22, 22, 22, 33, 29, 27, 18, 27, 27, 24, 20, 20, 21, 29, 23, 31, 23, 23, 22, 23,
30, 27, 28, 31, 16, 29, 25, 19, 33, 28, 25, 24, 15, 27, 37, 29, 15, 19, 14, 19, 24, 23, 30, 29,
35, 22, 19, 26, 26, 14, 24, 30, 32, 23, 30, 29, 26, 27, 25, 23, 17, 26, 32, 29, 20, 17, 21, 23,
22, 20, 36, 12, 26, 23, 15, 29, 24, 22, 26, 33, 24, 23, 20, 26, 22, 17, 26, 26, 34, 22, 26, 17,
23, 18, 29, 27, 21, 29, 28, 29, 24, 25, 28, 19, 18, 21, 23, 23, 27, 25, 24, 25, 24, 25, 21, 25,
21, 27, 23, 20, 29, 15, 28, 30, 24, 27, 17, 23, 16, 21, 25, 17, 27, 28, 21, 13, 19, 27, 16, 30,
31, 25, 30, 17, 17, 25, 26, 22, 21, 17, 24, 17, 25, 22, 27, 14, 27, 24, 27, 25, 26, 31, 21, 23,
30, 30, 22, 19, 23, 22, 23, 25, 24, 25, 24, 28, 26, 30, 18, 25, 30, 37, 27, 34, 28, 34, 25, 10,
25, 22, 35, 30, 24, 32, 24, 34, 19, 29, 26, 16, 27, 17, 26, 23, 27, 25, 26, 21, 31, 21, 28, 15,
32, 24, 23, 23, 18, 15, 22, 25, 16, 25, 31, 26, 25, 28, 24, 26, 23, 25, 33, 20, 27, 28, 24, 29,
32, 20, 24, 20, 19, 32, 24, 6, 24, 21, 26, 18, 15, 30, 19, 26, 22, 30, 35, 23, 22, 30, 20, 22,
18, 30, 28, 25, 16, 25, 27, 30, 18, 24, 30, 28, 20, 19, 20, 28, 21, 24, 15, 33, 20, 18, 20, 36,
30, 26, 25, 18, 28, 27, 31, 31, 15, 26, 16, 22, 27, 14, 17, 27, 27, 22, 32, 30, 22, 34, 22, 25,
20, 22, 26, 29, 28, 33, 18, 23, 20, 20, 27, 24, 28, 21, 25, 27, 25, 19, 19, 25, 19, 32, 29, 27,
23, 21, 28, 33, 23, 23, 28, 26, 31, 19, 21, 29, 21, 27, 23, 32, 24, 26, 21, 28, 28, 24, 17, 31,
27, 21, 19, 32, 28, 23, 30, 23, 29, 15, 26, 26, 15, 20, 25, 26, 27, 31, 21, 23, 23, 33, 28, 19,
23, 22, 22, 25, 27, 17, 23, 17, 25, 28, 26, 30, 32, 31, 19, 25, 25, 19, 23, 29, 27, 23, 34, 22,
13, 21, 32, 10, 20, 33, 21, 17, 29, 31, 14, 24, 23, 19, 19, 22, 17, 26, 37, 26, 22, 26, 38, 29,
29, 27, 30, 20, 31, 14, 32, 32, 24, 23, 23, 18, 21, 31, 24, 20, 28, 15, 21, 25, 25, 20, 30, 25,
22, 21, 21, 25, 24, 25, 18, 23, 28, 30, 20, 27, 27, 19, 10, 32, 24, 20, 29, 26, 25, 20, 25, 29,
28, 24, 32, 26, 22, 19, 23, 27, 27, 29, 20, 25, 21, 30, 28, 31, 24, 19, 23, 19, 19, 18, 30, 18,
16, 24, 20, 20, 30, 25, 29, 25, 31, 21, 28, 31, 24, 26, 27, 21, 24, 23, 26, 18, 32, 26, 28, 26,
24, 26, 29, 30, 22, 20, 24, 28, 25, 29, 20, 21, 22, 15, 30, 27, 33, 26, 22, 32, 30, 31, 20, 19,
24, 26, 27, 31, 17, 17, 33, 27, 16, 27, 27, 22, 27, 19, 24, 21, 17, 24, 28, 23, 26, 24, 19, 26,
20, 24, 22, 19, 22, 21, 21, 28, 29, 39, 19, 16, 25, 29, 31, 22, 22, 29, 26, 22, 22, 22, 26, 23,
23, 23, 30, 25, 25, 25, 27, 29, 18, 33, 21, 12, 22, 29, 12, 20, 35, 22, 34, 28, 18, 29, 21, 20,
24, 33, 24, 26, 23, 34, 31, 25, 31, 22, 35, 21, 20, 29, 27, 22, 30, 22, 27, 23, 22, 32, 16, 19,
27, 22, 24, 27, 21, 33, 25, 25, 19, 28, 20, 27, 21, 25, 28, 20, 27, 22, 21, 20, 26, 30, 33, 23,
20, 24, 17, 23, 28, 35, 14, 23, 22, 28, 28, 26, 25, 18, 20, 28, 28, 22, 13, 24, 22, 20, 30, 26,
26, 18, 22, 20, 23, 24, 20, 27, 34, 28, 18, 24, 34, 33, 25, 33, 37, 21, 20, 31, 19, 23, 29, 22,
21, 24, 19, 27, 19, 32, 25, 23, 33, 26, 33, 27, 29, 30, 19, 22, 30, 19, 18, 24, 25, 17, 31, 19,
31, 26, 22, 23, 28, 28, 25, 24, 19, 19, 27, 28, 23, 21, 29, 26, 31, 22, 22, 25, 16, 29, 21, 22,
23, 25, 22, 21, 22, 19, 27, 26, 28, 30, 22, 21, 24, 22, 23, 26, 28, 22, 18, 25, 23, 27, 31, 19,
15, 29, 20, 19, 27, 25, 21, 29, 22, 24, 25, 17, 36, 29, 22, 22, 24, 28, 27, 22, 26, 31, 29, 31,
18, 25, 23, 16, 37, 27, 21, 31, 25, 24, 20, 23, 28, 33, 24, 21, 26, 20, 18, 31, 20, 24, 23, 19,
27, 17, 23, 23, 20, 26, 28, 23, 26, 31, 25, 31, 19, 32, 26, 18, 19, 29, 20, 21, 15, 25, 27, 29,
22, 22, 22, 26, 23, 22, 23, 29, 28, 20, 21, 22, 20, 22, 27, 25, 23, 32, 23, 20, 31, 20, 27, 26,
34, 20, 22, 36, 21, 29, 25, 20, 21, 22, 29, 29, 25, 22, 24, 22
};
vtkm::Float32 fieldC[nVerts] = {
3, 1, 4, 6, 5, 4, 8, 7, 2, 9, 2, 0, 0, 4, 3, 2, 5, 2, 3, 6, 3, 8, 3, 4,
3, 3, 2, 7, 2, 10, 9, 6, 1, 1, 4, 7, 3, 3, 1, 4, 4, 3, 9, 4, 4, 7, 3, 2,
4, 7, 3, 3, 2, 10, 1, 6, 2, 2, 3, 8, 3, 3, 6, 9, 4, 1, 4, 3, 16, 7, 0, 1,
8, 7, 13, 3, 5, 0, 3, 8, 10, 3, 5, 5, 1, 5, 2, 1, 3, 2, 5, 3, 4, 3, 3, 3,
3, 1, 13, 2, 3, 1, 2, 7, 3, 4, 1, 2, 5, 4, 4, 4, 2, 6, 3, 2, 7, 8, 1, 3,
4, 1, 2, 0, 1, 6, 1, 8, 8, 1, 1, 4, 2, 1, 4, 3, 5, 4, 6, 4, 2, 3, 8, 8,
3, 3, 3, 4, 5, 8, 8, 16, 7, 12, 4, 3, 14, 8, 3, 12, 5, 0, 5, 3, 5, 2, 9, 2,
9, 4, 1, 0, 0, 4, 4, 6, 3, 4, 11, 2, 4, 7, 4, 2, 1, 9, 4, 3, 2, 5, 1, 5,
3, 8, 2, 8, 1, 8, 0, 4, 1, 3, 2, 1, 2, 3, 2, 1, 8, 5, 4, 1, 9, 9, 1, 3,
5, 0, 1, 6, 10, 8, 3, 12, 3, 4, 4, 7, 1, 3, 6, 4, 4, 6, 1, 4, 7, 5, 6, 11,
6, 5, 2, 7, 2, 5, 3, 5, 6, 3, 6, 2, 1, 10, 8, 3, 7, 0, 2, 6, 9, 3, 11, 3,
2, 5, 1, 4, 6, 10, 9, 1, 4, 3, 7, 12, 3, 10, 0, 2, 11, 2, 1, 0, 4, 1, 2, 16,
5, 17, 7, 8, 2, 10, 10, 3, 1, 3, 2, 2, 4, 8, 4, 3, 2, 4, 4, 6, 8, 6, 2, 3,
2, 4, 2, 4, 7, 10, 5, 3, 5, 2, 4, 6, 9, 3, 1, 1, 1, 1, 4, 2, 2, 7, 4, 9,
2, 3, 5, 6, 2, 5, 1, 6, 5, 7, 8, 3, 7, 2, 2, 8, 6, 2, 10, 2, 1, 4, 5, 1,
1, 1, 5, 6, 1, 1, 4, 5, 4, 2, 4, 3, 2, 7, 19, 4, 7, 2, 7, 5, 2, 5, 3, 8,
4, 6, 7, 2, 0, 0, 2, 12, 6, 2, 2, 3, 5, 9, 4, 9, 2, 2, 7, 8, 3, 3, 10, 6,
3, 2, 1, 6, 2, 4, 6, 3, 5, 8, 2, 3, 6, 14, 0, 3, 6, 5, 2, 7, 0, 3, 8, 5,
3, 2, 2, 5, 1, 3, 12, 11, 16, 2, 1, 3, 7, 3, 1, 6, 4, 3, 12, 5, 1, 3, 1, 4,
9, 1, 3, 3, 4, 4, 6, 7, 7, 5, 2, 4, 2, 3, 2, 2, 6, 4, 2, 2, 3, 5, 1, 4,
9, 1, 0, 7, 6, 4, 3, 3, 7, 3, 3, 6, 2, 7, 9, 3, 1, 16, 5, 4, 3, 6, 3, 2,
5, 2, 2, 4, 3, 1, 3, 3, 6, 3, 5, 9, 1, 10, 1, 7, 2, 2, 6, 7, 3, 5, 3, 7,
2, 2, 2, 2, 6, 4, 3, 2, 5, 5, 3, 15, 4, 2, 7, 7, 4, 3, 3, 5, 1, 2, 9, 0,
5, 7, 12, 2, 4, 8, 5, 7, 8, 3, 2, 2, 18, 1, 7, 2, 2, 1, 3, 3, 3, 7, 1, 9,
8, 4, 3, 7, 6, 4, 5, 2, 0, 5, 1, 5, 10, 4, 2, 8, 2, 2, 0, 5, 6, 4, 5, 0,
1, 5, 11, 3, 3, 4, 4, 2, 3, 5, 1, 6, 5, 7, 2, 2, 5, 7, 4, 8, 4, 1, 1, 7,
2, 3, 9, 6, 13, 1, 5, 4, 6, 2, 4, 11, 2, 5, 5, 1, 4, 1, 4, 7, 1, 5, 8, 3,
1, 10, 9, 13, 1, 7, 2, 9, 4, 3, 3, 10, 12, 2, 0, 4, 6, 5, 5, 1, 4, 7, 2, 12,
7, 6, 5, 0, 6, 4, 4, 12, 1, 3, 10, 1, 9, 2, 2, 2, 1, 5, 5, 6, 9, 6, 4, 1,
11, 6, 9, 3, 2, 7, 1, 7, 4, 3, 0, 3, 1, 12, 17, 2, 1, 6, 4, 4, 2, 1, 5, 5,
3, 2, 2, 4, 6, 5, 4, 6, 11, 3, 12, 6, 3, 6, 3, 0, 6, 3, 7, 4, 8, 5, 14, 5,
1, 9, 4, 6, 5, 3, 9, 3, 1, 1, 0, 3, 7, 3, 5, 1, 6, 2, 2, 6, 2, 12, 1, 0,
6, 3, 3, 5, 4, 7, 2, 2, 15, 7, 3, 10, 4, 2, 6, 3, 4, 8, 3, 1, 5, 5, 5, 4,
3, 7, 3, 4, 5, 5, 2, 4, 2, 5, 1, 12, 5, 6, 3, 2, 8, 5, 2, 3, 11, 11, 6, 5,
0, 3, 3, 9, 4, 2, 11, 1, 5, 3, 5, 6, 3, 6, 4, 2, 4, 10, 11, 3, 3, 4, 1, 1,
1, 3, 5, 5, 1, 1, 4, 1, 5, 1, 6, 8, 6, 4, 6, 7, 6, 3, 5, 3, 6, 6, 6, 4,
0, 6, 3, 1, 2, 4, 2, 6, 1, 1, 1, 2, 2, 4, 7, 2, 6, 2, 5, 7, 6, 4, 6, 3,
1, 4, 5, 1, 4, 6, 2, 3, 0, 6, 11, 2, 9, 2, 6, 4, 5, 6, 2, 19, 2, 10, 4, 2,
3, 3, 11, 7, 3, 3, 1, 5, 3, 6, 4, 3, 0, 6, 6, 6, 4, 2, 5, 2, 2, 2, 6, 10,
4, 9, 3, 7, 7, 0, 6, 8, 5, 2, 3, 2, 3, 3, 3, 1, 6, 1, 8, 2, 5, 3, 6, 11,
5, 7, 2, 6, 7, 3, 4, 1, 0, 5, 8, 3, 2, 9, 3, 1, 2, 3, 3, 9, 5, 6, 5, 1,
4, 5, 6, 7, 6, 1, 5, 1, 6, 6, 2, 6, 7, 2, 4, 6
};
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vtkm::Id3(xVerts, yVerts, 1));
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}
//
// Create a dataset with known point data
// Extract the three field
// Run NDimsEntropy to calculate the entropy
//
void TestNDimsEntropy()
{
// Data attached is the poisson distribution
vtkm::cont::DataSet ds = MakeTestDataSet();
vtkm::worklet::NDimsEntropy ndEntropy;
ndEntropy.SetNumOfDataPoints(ds.GetField(0).GetNumberOfValues());
// Add field one by one
ndEntropy.AddField(ds.GetField("fieldA").GetData(), 10);
ndEntropy.AddField(ds.GetField("fieldB").GetData(), 10);
ndEntropy.AddField(ds.GetField("fieldC").GetData(), 10);
// Run worklet to calculate multi-variate entropy
vtkm::Float64 entropy = ndEntropy.Run();
VTKM_TEST_ASSERT(fabs(entropy - 7.457857) < 0.001,
"N-Dimentional entropy calculation is incorrect");
} // TestNDimsEntropy
}
int UnitTestNDimsEntropy(int argc, char* argv[])
{
return vtkm::cont::testing::Testing::Run(TestNDimsEntropy, argc, argv);
}

2
vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx
View File

@ -8,8 +8,8 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/density_estimate/worklet/NDimsHistogram.h>
#include <vtkm/worklet/NDimsHistMarginalization.h>
#include <vtkm/worklet/NDimsHistogram.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/testing/Testing.h>

121
vtkm/worklet/testing/UnitTestNDimsHistogram.cxx
View File

@ -1,121 +0,0 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/worklet/NDimsHistogram.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/testing/Testing.h>
namespace
{
// Make testing dataset with three fields(variables), each one has 100 values
vtkm::cont::DataSet MakeTestDataSet()
{
vtkm::cont::DataSet dataSet;
const int nVerts = 100;
vtkm::Float32 fieldA[nVerts] = { 8, 10, 9, 8, 14, 11, 12, 9, 19, 7, 8, 11, 7, 10, 11,
11, 11, 6, 8, 8, 7, 15, 9, 7, 8, 10, 9, 10, 10, 12,
7, 6, 14, 10, 14, 10, 7, 11, 13, 9, 13, 11, 10, 10, 12,
12, 7, 12, 10, 11, 12, 8, 13, 9, 5, 12, 11, 9, 5, 9,
12, 9, 6, 10, 11, 9, 9, 11, 9, 7, 7, 18, 16, 13, 12,
8, 10, 11, 9, 8, 17, 3, 15, 15, 9, 10, 10, 8, 10, 9,
7, 9, 8, 10, 13, 9, 7, 11, 7, 10 };
vtkm::Float32 fieldB[nVerts] = { 24, 19, 28, 19, 25, 28, 25, 22, 27, 26, 35, 26, 30, 28, 24,
23, 21, 31, 20, 11, 21, 22, 14, 25, 20, 24, 24, 21, 24, 29,
26, 21, 32, 29, 23, 28, 31, 25, 23, 30, 18, 24, 22, 25, 33,
24, 22, 23, 21, 17, 20, 28, 30, 18, 20, 32, 25, 24, 32, 15,
27, 24, 27, 19, 30, 27, 17, 24, 29, 23, 22, 19, 24, 19, 28,
24, 25, 24, 25, 30, 24, 31, 30, 27, 25, 25, 25, 15, 29, 23,
29, 29, 21, 25, 35, 24, 28, 10, 31, 23 };
vtkm::Float32 fieldC[nVerts] = {
3, 1, 4, 6, 5, 4, 8, 7, 2, 9, 2, 0, 0, 4, 3, 2, 5, 2, 3, 6, 3, 8, 3, 4, 3,
3, 2, 7, 2, 10, 9, 6, 1, 1, 4, 7, 3, 3, 1, 4, 4, 3, 9, 4, 4, 7, 3, 2, 4, 7,
3, 3, 2, 10, 1, 6, 2, 2, 3, 8, 3, 3, 6, 9, 4, 1, 4, 3, 16, 7, 0, 1, 8, 7, 13,
3, 5, 0, 3, 8, 10, 3, 5, 5, 1, 5, 2, 1, 3, 2, 5, 3, 4, 3, 3, 3, 3, 1, 13, 2
};
// Set point scalars
dataSet.AddField(vtkm::cont::make_Field(
"fieldA", vtkm::cont::Field::Association::POINTS, fieldA, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldB", vtkm::cont::Field::Association::POINTS, fieldB, nVerts, vtkm::CopyFlag::On));
dataSet.AddField(vtkm::cont::make_Field(
"fieldC", vtkm::cont::Field::Association::POINTS, fieldC, nVerts, vtkm::CopyFlag::On));
return dataSet;
}
void TestNDimsHistogram()
{
// Create a dataset
vtkm::cont::DataSet ds = MakeTestDataSet();
vtkm::worklet::NDimsHistogram ndHistogram;
// Set the number of data points
ndHistogram.SetNumOfDataPoints(ds.GetField(0).GetNumberOfValues());
// Add field one by one
vtkm::Range rangeFieldA;
vtkm::Float64 deltaFieldA;
ndHistogram.AddField(ds.GetField("fieldA").GetData(), 4, rangeFieldA, deltaFieldA);
vtkm::Range rangeFieldB;
vtkm::Float64 deltaFieldB;
ndHistogram.AddField(ds.GetField("fieldB").GetData(), 4, rangeFieldB, deltaFieldB);
vtkm::Range rangeFieldC;
vtkm::Float64 deltaFieldC;
ndHistogram.AddField(ds.GetField("fieldC").GetData(), 4, rangeFieldC, deltaFieldC);
// the return binIds and freqs is sparse distribution representation
// (we do not keep the 0 frequency entities)
// e.g. we have three variable(data arrays) in this example
// binIds[0, 1, 2][j] is a combination of bin ID of three variable,
// freqs[j] is the frequency of this bin IDs combination
std::vector<vtkm::cont::ArrayHandle<vtkm::Id>> binIds;
vtkm::cont::ArrayHandle<vtkm::Id> freqs;
ndHistogram.Run(binIds, freqs);
// Ground truth ND histogram
vtkm::Id gtNonSparseBins = 33;
vtkm::Id gtIdx0[33] = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3 };
vtkm::Id gtIdx1[33] = { 1, 1, 2, 3, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 3,
0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 1, 1, 2, 2, 2, 3 };
vtkm::Id gtIdx2[33] = { 0, 1, 1, 0, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 3,
0, 0, 1, 0, 1, 2, 3, 0, 1, 2, 0, 2, 0, 1, 2, 1 };
vtkm::Id gtFreq[33] = { 1, 1, 1, 3, 2, 1, 1, 6, 6, 3, 17, 8, 2, 6, 2, 1, 2,
1, 1, 4, 11, 4, 1, 1, 3, 3, 1, 1, 1, 1, 1, 2, 1 };
// Check result
vtkm::Id nonSparseBins = binIds[0].WritePortal().GetNumberOfValues();
VTKM_TEST_ASSERT(nonSparseBins == gtNonSparseBins, "Incorrect ND-histogram results");
for (int i = 0; i < nonSparseBins; i++)
{
vtkm::Id idx0 = binIds[0].WritePortal().Get(i);
vtkm::Id idx1 = binIds[1].WritePortal().Get(i);
vtkm::Id idx2 = binIds[2].WritePortal().Get(i);
vtkm::Id f = freqs.WritePortal().Get(i);
VTKM_TEST_ASSERT(idx0 == gtIdx0[i] && idx1 == gtIdx1[i] && idx2 == gtIdx2[i] && f == gtFreq[i],
"Incorrect ND-histogram results");
}
} // TestNDHistogram
}
int UnitTestNDimsHistogram(int argc, char* argv[])
{
return vtkm::cont::testing::Testing::Run(TestNDimsHistogram, argc, argv);
}