1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
/**
* @class vtkGenericDataArrayLookupHelper
* @brief internal class used by
* vtkGenericDataArray to support LookupValue.
*
*/
#ifndef vtkGenericDataArrayLookupHelper_h
#define vtkGenericDataArrayLookupHelper_h
#include "vtkIdList.h"
#include <algorithm>
#include <cmath>
#include <limits>
#include <unordered_map>
#include <vector>
namespace vtkGenericDataArrayLookupHelper_detail
{
VTK_ABI_NAMESPACE_BEGIN
template <typename T, bool>
struct has_NaN;
template <typename T>
struct has_NaN<T, true>
{
static bool isnan(T x) { return std::isnan(x); }
};
template <typename T>
struct has_NaN<T, false>
{
static bool isnan(T) { return false; }
};
template <typename T>
bool isnan(T x)
{
// Select the correct partially specialized type.
return has_NaN<T, std::numeric_limits<T>::has_quiet_NaN>::isnan(x);
}
VTK_ABI_NAMESPACE_END
} // namespace detail
VTK_ABI_NAMESPACE_BEGIN
template <class ArrayTypeT>
class vtkGenericDataArrayLookupHelper
{
public:
typedef ArrayTypeT ArrayType;
typedef typename ArrayType::ValueType ValueType;
vtkGenericDataArrayLookupHelper() = default;
~vtkGenericDataArrayLookupHelper() { this->ClearLookup(); }
void SetArray(ArrayTypeT* array)
{
if (this->AssociatedArray != array)
{
this->ClearLookup();
this->AssociatedArray = array;
}
}
vtkIdType LookupValue(ValueType elem)
{
this->UpdateLookup();
auto indices = FindIndexVec(elem);
if (indices == nullptr)
{
return -1;
}
return indices->front();
}
void LookupValue(ValueType elem, vtkIdList* ids)
{
ids->Reset();
this->UpdateLookup();
auto indices = FindIndexVec(elem);
if (indices)
{
ids->Allocate(static_cast<vtkIdType>(indices->size()));
for (auto index : *indices)
{
ids->InsertNextId(index);
}
}
}
///@{
/**
* Release any allocated memory for internal data-structures.
*/
void ClearLookup()
{
this->ValueMap.clear();
this->NanIndices.clear();
}
///@}
private:
vtkGenericDataArrayLookupHelper(const vtkGenericDataArrayLookupHelper&) = delete;
void operator=(const vtkGenericDataArrayLookupHelper&) = delete;
void UpdateLookup()
{
if (!this->AssociatedArray || (this->AssociatedArray->GetNumberOfTuples() < 1) ||
(!this->ValueMap.empty() || !this->NanIndices.empty()))
{
return;
}
vtkIdType num = this->AssociatedArray->GetNumberOfValues();
this->ValueMap.reserve(num);
for (vtkIdType i = 0; i < num; ++i)
{
auto value = this->AssociatedArray->GetValue(i);
if (vtkGenericDataArrayLookupHelper_detail::isnan(value))
{
NanIndices.push_back(i);
}
this->ValueMap[value].push_back(i);
}
}
// Return a pointer to the relevant vector of indices if specified value was
// found in the array.
std::vector<vtkIdType>* FindIndexVec(ValueType value)
{
std::vector<vtkIdType>* indices{ nullptr };
if (vtkGenericDataArrayLookupHelper_detail::isnan(value) && !this->NanIndices.empty())
{
indices = &this->NanIndices;
}
const auto& pos = this->ValueMap.find(value);
if (pos != this->ValueMap.end())
{
indices = &pos->second;
}
return indices;
}
ArrayTypeT* AssociatedArray{ nullptr };
std::unordered_map<ValueType, std::vector<vtkIdType>> ValueMap;
std::vector<vtkIdType> NanIndices;
};
VTK_ABI_NAMESPACE_END
#endif
// VTK-HeaderTest-Exclude: vtkGenericDataArrayLookupHelper.h
|
