138 #ifndef vtkCellArray_h
139 #define vtkCellArray_h
141 #include "vtkCommonDataModelModule.h"
147 #include "vtkFeatures.h"
149 #include "vtkTypeInt32Array.h"
150 #include "vtkTypeInt64Array.h"
154 #include <initializer_list>
155 #include <type_traits>
178 #define VTK_CELL_ARRAY_V2
180 VTK_ABI_NAMESPACE_BEGIN
233 return this->AllocateExact(sz, sz) ? 1 : 0;
247 return this->AllocateExact(numCells, numCells * maxCellSize);
401 void SetData(vtkTypeInt32Array* offsets, vtkTypeInt32Array* connectivity);
402 void SetData(vtkTypeInt64Array* offsets, vtkTypeInt64Array* connectivity);
515 return this->GetOffsetsArray64();
519 return this->GetOffsetsArray32();
536 return this->GetConnectivityArray64();
540 return this->GetConnectivityArray32();
566 void InitTraversal();
628 VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());
661 return this->InsertNextCell(
static_cast<vtkIdType>(cell.size()), cell.begin());
682 void UpdateCellCount(
int npts);
731 return this->ReplaceCellAtId(cellId,
static_cast<vtkIdType>(cell.size()), cell.begin());
806 unsigned long GetActualMemorySize() const;
814 template <
typename ArrayT>
819 using CellRangeType = decltype(vtk::DataArrayValueRange<1>(std::declval<ArrayType>()));
852 this->Offsets->InsertNextValue(0);
855 this->IsInMemkind =
true;
859 void*
operator new(
size_t nSize)
862 #ifdef VTK_USE_MEMKIND
869 void operator delete(
void* p)
871 #ifdef VTK_USE_MEMKIND
892 bool IsInMemkind =
false;
896 template <
typename Functor,
typename... Args>
897 using GetReturnType = decltype(
900 template <
typename Functor,
typename... Args>
901 struct ReturnsVoid : std::is_same<GetReturnType<Functor, Args...>, void>
975 template <
typename Functor,
typename... Args,
976 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>
::value>
::type>
977 void Visit(Functor&& functor, Args&&... args)
995 template <
typename Functor,
typename... Args,
996 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>
::value>
::type>
997 void Visit(Functor&& functor, Args&&... args)
const
1015 template <
typename Functor,
typename... Args,
1016 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>
::value>
::type>
1017 GetReturnType<Functor, Args...>
Visit(Functor&& functor, Args&&... args)
1034 template <
typename Functor,
typename... Args,
1035 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>
::value>
::type>
1036 GetReturnType<Functor, Args...>
Visit(Functor&& functor, Args&&... args)
const
1119 VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries());
1214 #ifdef VTK_USE_MEMKIND
1222 #ifdef VTK_USE_64BIT_IDS
1225 this->StorageIs64Bit =
true;
1230 this->StorageIs64Bit =
false;
1233 #ifdef VTK_USE_MEMKIND
1236 this->IsInMemkind =
true;
1239 (void)this->IsInMemkind;
1245 if (this->StorageIs64Bit)
1247 this->Arrays->Int64->~VisitState();
1248 delete this->Arrays->Int64;
1252 this->Arrays->Int32->~VisitState();
1253 delete this->Arrays->Int32;
1255 #ifdef VTK_USE_MEMKIND
1256 if (this->IsInMemkind)
1265 delete this->Arrays;
1273 if (!this->StorageIs64Bit)
1278 this->Arrays->Int64->~VisitState();
1279 delete this->Arrays->Int64;
1281 this->StorageIs64Bit =
false;
1290 if (this->StorageIs64Bit)
1295 this->Arrays->Int32->~VisitState();
1296 delete this->Arrays->Int32;
1298 this->StorageIs64Bit =
true;
1304 bool Is64Bit()
const {
return this->StorageIs64Bit; }
1309 assert(!this->StorageIs64Bit);
1310 return *this->Arrays->Int32;
1315 assert(!this->StorageIs64Bit);
1316 return *this->Arrays->Int32;
1322 assert(this->StorageIs64Bit);
1323 return *this->Arrays->Int64;
1328 assert(this->StorageIs64Bit);
1329 return *this->Arrays->Int64;
1335 ArraySwitch* Arrays;
1336 bool StorageIs64Bit;
1337 bool IsInMemkind =
false;
1351 template <
typename ArrayT>
1354 return this->Offsets->GetNumberOfValues() - 1;
1357 template <
typename ArrayT>
1360 return static_cast<vtkIdType>(this->Offsets->GetValue(cellId));
1363 template <
typename ArrayT>
1366 return static_cast<vtkIdType>(this->Offsets->GetValue(cellId + 1));
1369 template <
typename ArrayT>
1372 return this->GetEndOffset(cellId) - this->GetBeginOffset(cellId);
1375 template <
typename ArrayT>
1379 return vtk::DataArrayValueRange<1>(
1380 this->
GetConnectivity(), this->GetBeginOffset(cellId), this->GetEndOffset(cellId));
1382 VTK_ABI_NAMESPACE_END
1386 VTK_ABI_NAMESPACE_BEGIN
1391 template <
typename CellStateT>
1394 using ValueType =
typename CellStateT::ValueType;
1395 auto* conn = state.GetConnectivity();
1396 auto* offsets = state.GetOffsets();
1398 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1400 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1404 conn->InsertNextValue(
static_cast<ValueType
>(pts[i]));
1411 template <
typename CellStateT>
1414 using ValueType =
typename CellStateT::ValueType;
1415 auto* conn = state.GetConnectivity();
1416 auto* offsets = state.GetOffsets();
1418 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1420 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1429 template <
typename CellStateT>
1432 using ValueType =
typename CellStateT::ValueType;
1434 auto* offsets = state.GetOffsets();
1435 const ValueType cellBegin = offsets->GetValue(offsets->GetMaxId() - 1);
1436 offsets->SetValue(offsets->GetMaxId(),
static_cast<ValueType
>(cellBegin + npts));
1442 template <
typename CellStateT>
1445 return state.GetCellSize(cellId);
1451 template <
typename CellStateT>
1454 using ValueType =
typename CellStateT::ValueType;
1456 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1457 const vtkIdType endOffset = state.GetEndOffset(cellId);
1458 const vtkIdType cellSize = endOffset - beginOffset;
1459 const auto cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1464 for (ValueType i = 0; i < cellSize; ++i)
1466 idPtr[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1472 template <
typename CellStateT>
1476 using ValueType =
typename CellStateT::ValueType;
1477 using ArrayType =
typename CellStateT::ArrayType;
1479 static constexpr
bool ValueTypeCompat = CellStateT::ValueTypeIsSameAsIdType;
1483 static constexpr
bool value = ValueTypeCompat && ArrayTypeCompat;
1486 template <
typename CellStateT>
1491 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1492 const vtkIdType endOffset = state.GetEndOffset(cellId);
1493 cellSize = endOffset - beginOffset;
1495 cellPoints =
reinterpret_cast<vtkIdType*
>(state.GetConnectivity()->GetPointer(beginOffset));
1498 template <
typename CellStateT>
1503 using ValueType =
typename CellStateT::ValueType;
1505 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1506 const vtkIdType endOffset = state.GetEndOffset(cellId);
1507 cellSize = endOffset - beginOffset;
1508 const ValueType* cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1513 for (
vtkIdType i = 0; i < cellSize; ++i)
1515 tempPtr[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1524 template <
typename CellStateT>
1527 state.GetOffsets()->Reset();
1528 state.GetConnectivity()->Reset();
1529 state.GetOffsets()->InsertNextValue(0);
1533 VTK_ABI_NAMESPACE_END
1536 VTK_ABI_NAMESPACE_BEGIN
1546 if (this->TraversalCellId < this->GetNumberOfCells())
1548 this->GetCellAtId(this->TraversalCellId, npts, pts);
1549 ++this->TraversalCellId;
1615 using ValueType =
typename ArrayType64::ValueType;
1620 using ValueType =
typename ArrayType32::ValueType;
1652 VTK_ABI_NAMESPACE_END
Encapsulate traversal logic for vtkCellArray.
object to represent cell connectivity
void SetData(vtkAOSDataArrayTemplate< int > *offsets, vtkAOSDataArrayTemplate< int > *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
int GetNextCell(vtkIdType &npts, vtkIdType const *&pts)
vtkIdType GetNumberOfConnectivityEntries()
Return the size of the array that would be returned from ExportLegacyFormat().
void SetData(vtkTypeInt32Array *offsets, vtkTypeInt32Array *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
vtkTypeBool Allocate(vtkIdType sz, vtkIdType vtkNotUsed(ext)=1000)
Allocate memory.
void UseDefaultStorage()
Initialize internal data structures to use 32- or 64-bit storage.
vtkIdType GetOffset(vtkIdType cellId)
Get the offset (into the connectivity) for a specified cell id.
vtkIdType GetCellSize(vtkIdType cellId) const
Return the size of the cell at cellId.
bool AllocateCopy(vtkCellArray *other)
Pre-allocate memory in internal data structures to match the used size of the input vtkCellArray.
void AppendLegacyFormat(vtkIdTypeArray *data, vtkIdType ptOffset=0)
Append an array of data with the legacy vtkCellArray layout, e.g.
bool IsStorageShareable() const
ArrayType32 * GetOffsetsArray32()
Return the array used to store cell offsets.
bool IsValid()
Check that internal storage is consistent and in a valid state.
void AppendLegacyFormat(const vtkIdType *data, vtkIdType len, vtkIdType ptOffset=0)
Append an array of data with the legacy vtkCellArray layout, e.g.
bool SetData(vtkIdType cellSize, vtkDataArray *connectivity)
Sets the internal arrays to the supported connectivity array with an offsets array automatically gene...
vtkIdType GetTraversalCellId()
Get/Set the current cellId for traversal.
void Visit(Functor &&functor, Args &&... args)
vtkTypeInt32Array ArrayType32
ArrayType64 * GetOffsetsArray64()
Return the array used to store cell offsets.
void SetData(vtkAOSDataArrayTemplate< long long > *offsets, vtkAOSDataArrayTemplate< long long > *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
GetReturnType< Functor, Args... > Visit(Functor &&functor, Args &&... args)
bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize)
Pre-allocate memory in internal data structures.
bool ResizeExact(vtkIdType numCells, vtkIdType connectivitySize)
ResizeExact() resizes the internal structures to hold numCells total cell offsets and connectivitySiz...
vtkIdType EstimateSize(vtkIdType numCells, int maxPtsPerCell)
Utility routines help manage memory of cell array.
bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize)
Pre-allocate memory in internal data structures.
vtkIdType GetNumberOfOffsets() const
Get the number of elements in the offsets array.
vtkTypeInt64Array ArrayType64
vtkIdType TraversalCellId
void Use64BitStorage()
Initialize internal data structures to use 32- or 64-bit storage.
bool ConvertToDefaultStorage()
Convert internal data structures to use 32- or 64-bit storage.
bool CanConvertToDefaultStorage() const
Check if the existing data can safely be converted to use 32- or 64- bit storage.
void GetCell(vtkIdType loc, vtkIdType &npts, const vtkIdType *&pts)
Internal method used to retrieve a cell given a legacy offset location.
bool CanConvertTo32BitStorage() const
Check if the existing data can safely be converted to use 32- or 64- bit storage.
void InsertCellPoint(vtkIdType id)
Used in conjunction with InsertNextCell(npts) to add another point to the list of cells.
void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints)
Return the point ids for the cell at cellId.
void ReplaceCellAtId(vtkIdType cellId, vtkIdList *list)
Replaces the point ids for the specified cell with the supplied list.
void ReverseCellAtId(vtkIdType cellId)
Reverses the order of the point ids for the specified cell.
bool SetData(vtkDataArray *offsets, vtkDataArray *connectivity)
Sets the internal arrays to the supplied offsets and connectivity arrays.
void Squeeze()
Reclaim any extra memory while preserving data.
void SetData(vtkIdTypeArray *offsets, vtkIdTypeArray *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
static vtkCellArray * New()
Standard methods for instantiation, type information, and printing.
ArrayType32 * GetConnectivityArray32()
Return the array used to store the point ids that define the cells' connectivity.
ArrayType64 * GetConnectivityArray64()
Return the array used to store the point ids that define the cells' connectivity.
bool ConvertTo32BitStorage()
Convert internal data structures to use 32- or 64-bit storage.
vtkIdType IsHomogeneous()
Check if all cells have the same number of vertices.
void Visit(Functor &&functor, Args &&... args) const
int GetMaxCellSize()
Returns the size of the largest cell.
bool ConvertToSmallestStorage()
Convert internal data structures to use 32- or 64-bit storage.
void ShallowCopy(vtkCellArray *ca)
Shallow copy ca into this cell array.
void ExportLegacyFormat(vtkIdTypeArray *data)
Fill data with the old-style vtkCellArray data layout, e.g.
bool ConvertTo64BitStorage()
Convert internal data structures to use 32- or 64-bit storage.
void SetData(vtkAOSDataArrayTemplate< long > *offsets, vtkAOSDataArrayTemplate< long > *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
void ImportLegacyFormat(const vtkIdType *data, vtkIdType len)
Import an array of data with the legacy vtkCellArray layout, e.g.
void ImportLegacyFormat(vtkIdTypeArray *data)
Import an array of data with the legacy vtkCellArray layout, e.g.
void Use32BitStorage()
Initialize internal data structures to use 32- or 64-bit storage.
void Initialize()
Free any memory and reset to an empty state.
void DeepCopy(vtkCellArray *ca)
Perform a deep copy (no reference counting) of the given cell array.
typename vtkTypeList::Unique< vtkTypeList::Create< vtkAOSDataArrayTemplate< int >, vtkAOSDataArrayTemplate< long >, vtkAOSDataArrayTemplate< long long > >>::Result InputArrayList
List of possible ArrayTypes that are compatible with internal storage.
vtkDataArray * GetConnectivityArray()
Return the array used to store the point ids that define the cells' connectivity.
void SetTraversalCellId(vtkIdType cellId)
Get/Set the current cellId for traversal.
void SetData(vtkTypeInt64Array *offsets, vtkTypeInt64Array *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
vtkIdType GetNumberOfCells() const
Get the number of cells in the array.
vtkIdType InsertNextCell(vtkCell *cell)
Insert a cell object.
virtual void SetNumberOfCells(vtkIdType)
Set the number of cells in the array.
vtkIdType GetNumberOfConnectivityIds() const
Get the size of the connectivity array that stores the point ids.
vtkNew< vtkIdTypeArray > LegacyData
void PrintSelf(ostream &os, vtkIndent indent) override
Standard methods for instantiation, type information, and printing.
void PrintDebug(ostream &os)
Standard methods for instantiation, type information, and printing.
vtkCellArrayIterator * NewIterator()
NewIterator returns a new instance of vtkCellArrayIterator that is initialized to point at the first ...
void UpdateCellCount(int npts)
Used in conjunction with InsertNextCell(int npts) and InsertCellPoint() to update the number of point...
GetReturnType< Functor, Args... > Visit(Functor &&functor, Args &&... args) const
vtkNew< vtkIdList > TempCell
vtkIdType GetSize()
Get the size of the allocated connectivity array.
vtkDataArray * GetOffsetsArray()
Return the array used to store cell offsets.
vtkTypeList::Create< ArrayType32, ArrayType64 > StorageArrayList
List of possible array types used for storage.
vtkIdType InsertNextCell(const std::initializer_list< vtkIdType > &cell)
Overload that allows InsertNextCell({0, 1, 2}) syntax.
void Append(vtkCellArray *src, vtkIdType pointOffset=0)
Append cells from src into this.
bool IsStorage64Bit() const
void ReplaceCellAtId(vtkIdType cellId, vtkIdType cellSize, const vtkIdType *cellPoints)
Replaces the point ids for the specified cell with the supplied list.
bool CanConvertTo64BitStorage() const
Check if the existing data can safely be converted to use 32- or 64- bit storage.
abstract class to specify cell behavior
vtkIdList * GetPointIds()
Return the list of point ids defining the cell.
abstract superclass for arrays of numeric data
list of point or cell ids
void SetNumberOfIds(vtkIdType number)
Specify the number of ids for this object to hold.
vtkIdType GetNumberOfIds() const noexcept
Return the number of id's in the list.
void Reset()
Reset to an empty state but retain previously allocated memory.
vtkIdType * GetPointer(vtkIdType i)
Get a pointer to a particular data index.
dynamic, self-adjusting array of vtkIdType
a simple class to control print indentation
static vtkMallocingFunction GetCurrentMallocFunction()
static vtkFreeingFunction GetAlternateFreeFunction()
static bool GetUsingMemkind()
A global state flag that controls whether vtkObjects are constructed in the usual way (the default) o...
abstract base class for most VTK objects
static vtkSmartPointer< T > New()
Create an instance of a VTK object.
vtkSmartPointer< vtkDataArray > GetData(const Ioss::GroupingEntity *entity, const std::string &fieldname, Ioss::Transform *transform=nullptr, Cache *cache=nullptr, const std::string &cachekey=std::string())
Returns a VTK array for a given field (fieldname) on the chosen block (or set) entity.
vtkSmartPointer< vtkCellArray > GetConnectivity(Ioss::GroupingEntity *group_entity, int &vtk_topology_type, Cache *cache=nullptr)
Read connectivity information from the group_entity.
VisitState< ArrayType32 > & GetArrays32()
const VisitState< ArrayType64 > & GetArrays64() const
const VisitState< ArrayType32 > & GetArrays32() const
VisitState< ArrayType64 > & GetArrays64()
vtkIdType GetNumberOfCells() const
vtkIdType GetEndOffset(vtkIdType cellId) const
vtkSmartPointer< ArrayType > Offsets
vtkSmartPointer< ArrayType > Connectivity
ArrayType * GetConnectivity()
decltype(vtk::DataArrayValueRange< 1 >(std::declval< ArrayType >())) CellRangeType
CellRangeType GetCellRange(vtkIdType cellId)
const ArrayType * GetOffsets() const
vtkIdType GetBeginOffset(vtkIdType cellId) const
vtkIdType GetCellSize(vtkIdType cellId) const
const ArrayType * GetConnectivity() const
typename ArrayType::ValueType ValueType
void operator()(CellStateT &state, const vtkIdType cellId, vtkIdList *ids)
std::enable_if<!CanShareConnPtr< CellStateT >::value, void >::type operator()(CellStateT &state, const vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints, vtkIdList *temp)
std::enable_if< CanShareConnPtr< CellStateT >::value, void >::type operator()(CellStateT &state, const vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints, vtkIdList *vtkNotUsed(temp))
vtkIdType operator()(CellStateT &state, vtkIdType cellId)
vtkIdType operator()(CellStateT &state, const vtkIdType npts, const vtkIdType pts[])
vtkIdType operator()(CellStateT &state, const vtkIdType npts)
void operator()(CellStateT &state)
void operator()(CellStateT &state, const vtkIdType npts)
Remove all duplicate types from TypeList TList, storing the new list in Result.
VisitState< ArrayType32 > * Int32
VisitState< ArrayType64 > * Int64
STL-compatible iterable ranges that provide access to vtkDataArray elements.
#define VTK_SIZEHINT(...)