129#ifndef vtkCellArray_h
130#define vtkCellArray_h
132#include "vtkCommonDataModelModule.h"
138#include "vtkFeatures.h"
140#include "vtkTypeInt32Array.h"
141#include "vtkTypeInt64Array.h"
145#include <initializer_list>
146#include <type_traits>
169#define VTK_CELL_ARRAY_V2
171VTK_ABI_NAMESPACE_BEGIN
224 return this->AllocateExact(
sz,
sz) ? 1 : 0;
238 return this->AllocateExact(numCells, numCells *
maxCellSize);
263 return this->AllocateExact(
other->GetNumberOfCells(),
other->GetNumberOfConnectivityIds());
506 return this->GetOffsetsArray64();
510 return this->GetOffsetsArray32();
527 return this->GetConnectivityArray64();
531 return this->GetConnectivityArray32();
557 void InitTraversal();
673 void UpdateCellCount(
int npts);
797 unsigned long GetActualMemorySize()
const;
805 template <
typename ArrayT>
810 using CellRangeType =
decltype(vtk::DataArrayValueRange<1>(std::declval<ArrayType>()));
817 static constexpr bool ValueTypeIsSameAsIdType = std::is_integral<ValueType>::value &&
843 this->Offsets->InsertNextValue(0);
846 this->IsInMemkind =
true;
853#ifdef VTK_USE_MEMKIND
860 void operator delete(
void* p)
862#ifdef VTK_USE_MEMKIND
883 bool IsInMemkind =
false;
887 template <
typename Functor,
typename...
Args>
888 using GetReturnType =
decltype(
889 std::declval<Functor>()(std::declval<VisitState<ArrayType32>&>(), std::declval<Args>()...));
891 template <
typename Functor,
typename...
Args>
892 struct ReturnsVoid : std::is_same<GetReturnType<Functor, Args...>, void>
966 template <
typename Functor,
typename... Args,
967 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
986 template <
typename Functor,
typename... Args,
987 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
1006 template <
typename Functor,
typename... Args,
1007 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
1025 template <
typename Functor,
typename... Args,
1026 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
1205#ifdef VTK_USE_MEMKIND
1213#ifdef VTK_USE_64BIT_IDS
1216 this->StorageIs64Bit =
true;
1221 this->StorageIs64Bit =
false;
1224#ifdef VTK_USE_MEMKIND
1227 this->IsInMemkind =
true;
1230 (
void)this->IsInMemkind;
1236 if (this->StorageIs64Bit)
1238 this->Arrays->Int64->~VisitState();
1239 delete this->Arrays->Int64;
1243 this->Arrays->Int32->~VisitState();
1244 delete this->Arrays->Int32;
1246#ifdef VTK_USE_MEMKIND
1247 if (this->IsInMemkind)
1256 delete this->Arrays;
1264 if (!this->StorageIs64Bit)
1269 this->Arrays->Int64->~VisitState();
1270 delete this->Arrays->Int64;
1272 this->StorageIs64Bit =
false;
1281 if (this->StorageIs64Bit)
1286 this->Arrays->Int32->~VisitState();
1287 delete this->Arrays->Int32;
1289 this->StorageIs64Bit =
true;
1295 bool Is64Bit()
const {
return this->StorageIs64Bit; }
1300 assert(!this->StorageIs64Bit);
1301 return *this->Arrays->Int32;
1306 assert(!this->StorageIs64Bit);
1307 return *this->Arrays->Int32;
1313 assert(this->StorageIs64Bit);
1314 return *this->Arrays->Int64;
1319 assert(this->StorageIs64Bit);
1320 return *this->Arrays->Int64;
1326 ArraySwitch* Arrays;
1327 bool StorageIs64Bit;
1328 bool IsInMemkind =
false;
1342template <
typename ArrayT>
1345 return this->Offsets->GetNumberOfValues() - 1;
1348template <
typename ArrayT>
1354template <
typename ArrayT>
1360template <
typename ArrayT>
1363 return this->GetEndOffset(
cellId) - this->GetBeginOffset(
cellId);
1366template <
typename ArrayT>
1370 return vtk::DataArrayValueRange<1>(
1371 this->GetConnectivity(), this->GetBeginOffset(
cellId), this->GetEndOffset(
cellId));
1377VTK_ABI_NAMESPACE_BEGIN
1382 template <
typename CellStateT>
1385 using ValueType =
typename CellStateT::ValueType;
1386 auto* conn = state.GetConnectivity();
1387 auto* offsets = state.GetOffsets();
1389 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1391 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1395 conn->InsertNextValue(
static_cast<ValueType
>(pts[i]));
1402 template <
typename CellStateT>
1405 using ValueType =
typename CellStateT::ValueType;
1406 auto* conn = state.GetConnectivity();
1407 auto* offsets = state.GetOffsets();
1409 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1411 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1420 template <
typename CellStateT>
1423 using ValueType =
typename CellStateT::ValueType;
1425 auto* offsets = state.GetOffsets();
1426 const ValueType cellBegin = offsets->GetValue(offsets->GetMaxId() - 1);
1427 offsets->SetValue(offsets->GetMaxId(),
static_cast<ValueType
>(cellBegin + npts));
1433 template <
typename CellStateT>
1436 return state.GetCellSize(cellId);
1442 template <
typename CellStateT>
1445 using ValueType =
typename CellStateT::ValueType;
1447 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1448 const vtkIdType endOffset = state.GetEndOffset(cellId);
1449 const vtkIdType cellSize = endOffset - beginOffset;
1450 const auto cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1455 for (ValueType i = 0; i < cellSize; ++i)
1457 idPtr[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1463 template <
typename CellStateT>
1467 using ValueType =
typename CellStateT::ValueType;
1468 using ArrayType =
typename CellStateT::ArrayType;
1470 static constexpr bool ValueTypeCompat = CellStateT::ValueTypeIsSameAsIdType;
1471 static constexpr bool ArrayTypeCompat = std::is_base_of<AOSArrayType, ArrayType>::value;
1474 static constexpr bool value = ValueTypeCompat && ArrayTypeCompat;
1477 template <
typename CellStateT>
1478 typename std::enable_if<CanShareConnPtr<CellStateT>::value,
void>::type
operator()(
1482 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1483 const vtkIdType endOffset = state.GetEndOffset(cellId);
1484 cellSize = endOffset - beginOffset;
1486 cellPoints =
reinterpret_cast<vtkIdType*
>(state.GetConnectivity()->GetPointer(beginOffset));
1489 template <
typename CellStateT>
1490 typename std::enable_if<!CanShareConnPtr<CellStateT>::value,
void>::type
operator()(
1494 using ValueType =
typename CellStateT::ValueType;
1496 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1497 const vtkIdType endOffset = state.GetEndOffset(cellId);
1498 cellSize = endOffset - beginOffset;
1499 const ValueType* cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1504 for (
vtkIdType i = 0; i < cellSize; ++i)
1506 tempPtr[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1515 template <
typename CellStateT>
1518 state.GetOffsets()->Reset();
1519 state.GetConnectivity()->Reset();
1520 state.GetOffsets()->InsertNextValue(0);
1524VTK_ABI_NAMESPACE_END
1527VTK_ABI_NAMESPACE_BEGIN
1606 using ValueType =
typename ArrayType64::ValueType;
1611 using ValueType =
typename ArrayType32::ValueType;
1643VTK_ABI_NAMESPACE_END
Array-Of-Structs implementation of vtkGenericDataArray.
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
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.:
GetReturnType< Functor, Args... > Visit(Functor &&functor, Args &&... args) const
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)
ArrayType64 * GetConnectivityArray64()
Return the array used to store the point ids that define the cells' connectivity.
ArrayType32 * GetConnectivityArray32()
Return the array used to store the point ids that define the cells' connectivity.
void SetData(vtkAOSDataArrayTemplate< long long > *offsets, vtkAOSDataArrayTemplate< long long > *connectivity)
Set the internal data arrays to the supplied offsets and connectivity arrays.
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.
ArrayType32 * GetOffsetsArray32()
Return the array used to store cell offsets.
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.
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.
vtkDataArray * GetConnectivityArray()
Return the array used to store the point ids that define the cells' connectivity.
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.
vtkCellArrayIterator * NewIterator()
NewIterator returns a new instance of vtkCellArrayIterator that is initialized to point at the first ...
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.
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.
ArrayType64 * GetOffsetsArray64()
Return the array used to store cell offsets.
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.
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.
vtkDataArray * GetOffsetsArray()
Return the array used to store cell offsets.
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.
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)
static vtkCellArray * New()
Standard methods for instantiation, type information, and printing.
vtkNew< vtkIdList > TempCell
vtkIdType GetSize()
Get the size of the allocated connectivity array.
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
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.
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.
VisitState< ArrayType64 > & GetArrays64()
const VisitState< ArrayType64 > & GetArrays64() const
const VisitState< ArrayType32 > & GetArrays32() const
VisitState< ArrayType32 > & GetArrays32()
vtkIdType GetNumberOfCells() const
vtkIdType GetEndOffset(vtkIdType cellId) const
vtkSmartPointer< ArrayType > Offsets
vtkSmartPointer< ArrayType > Connectivity
const ArrayType * GetOffsets() const
decltype(vtk::DataArrayValueRange< 1 >(std::declval< ArrayType >())) CellRangeType
CellRangeType GetCellRange(vtkIdType cellId)
vtkIdType GetBeginOffset(vtkIdType cellId) const
vtkIdType GetCellSize(vtkIdType cellId) const
const ArrayType * GetConnectivity() const
typename ArrayType::ValueType ValueType
ArrayType * GetConnectivity()
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))
void operator()(CellStateT &state, const vtkIdType cellId, vtkIdList *ids)
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(...)