238#ifndef vtkCellArray_h
239#define vtkCellArray_h
242#include "vtkCommonDataModelModule.h"
248#include "vtkFeatures.h"
250#include "vtkTypeInt32Array.h"
251#include "vtkTypeInt64Array.h"
255#include <initializer_list>
256#include <type_traits>
279#define VTK_CELL_ARRAY_V2
281VTK_ABI_NAMESPACE_BEGIN
334 return this->AllocateExact(sz, sz) ? 1 : 0;
348 return this->AllocateExact(numCells, numCells * maxCellSize);
517 void SetData(vtkTypeInt32Array* offsets, vtkTypeInt32Array* connectivity);
518 void SetData(vtkTypeInt64Array* offsets, vtkTypeInt64Array* connectivity);
631 return this->GetOffsetsArray64();
635 return this->GetOffsetsArray32();
652 return this->GetConnectivityArray64();
656 return this->GetConnectivityArray32();
682 void InitTraversal();
749 VTK_EXPECTS(0 <= cellPointIndex && cellPointIndex < this->GetCellSize(cellId));
782 return this->InsertNextCell(
static_cast<vtkIdType>(cell.size()), cell.begin());
803 void UpdateCellCount(
int npts);
852 this->ReplaceCellAtId(cellId,
static_cast<vtkIdType>(cell.size()), cell.begin());
927 unsigned long GetActualMemorySize() const;
935 template <
typename ArrayT>
940 using CellRangeType =
decltype(vtk::DataArrayValueRange<1>(std::declval<ArrayType>()));
947 static constexpr bool ValueTypeIsSameAsIdType = std::is_integral<ValueType>::value &&
973 this->Offsets->InsertNextValue(0);
976 this->IsInMemkind =
true;
980 void*
operator new(
size_t nSize)
983#ifdef VTK_USE_MEMKIND
990 void operator delete(
void* p)
992#ifdef VTK_USE_MEMKIND
1013 bool IsInMemkind =
false;
1017 template <
typename Functor,
typename... Args>
1018 using GetReturnType =
decltype(std::declval<Functor>()(
1019 std::declval<VisitState<ArrayType32>&>(), std::declval<Args>()...));
1021 template <
typename Functor,
typename... Args>
1022 struct ReturnsVoid : std::is_same<GetReturnType<Functor, Args...>, void>
1096 template <
typename Functor,
typename... Args,
1097 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
1098 void Visit(Functor&& functor, Args&&... args)
1116 template <
typename Functor,
typename... Args,
1117 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
1118 void Visit(Functor&& functor, Args&&... args)
const
1136 template <
typename Functor,
typename... Args,
1137 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
1138 GetReturnType<Functor, Args...>
Visit(Functor&& functor, Args&&... args)
1155 template <
typename Functor,
typename... Args,
1156 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
1157 GetReturnType<Functor, Args...>
Visit(Functor&& functor, Args&&... args)
const
1250 VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries());
1346#ifdef VTK_USE_MEMKIND
1357 this->StorageIs64Bit =
true;
1362 this->StorageIs64Bit =
false;
1365#ifdef VTK_USE_MEMKIND
1368 this->IsInMemkind =
true;
1371 (void)this->IsInMemkind;
1377 if (this->StorageIs64Bit)
1379 this->Arrays->Int64->~VisitState();
1380 delete this->Arrays->Int64;
1384 this->Arrays->Int32->~VisitState();
1385 delete this->Arrays->Int32;
1387#ifdef VTK_USE_MEMKIND
1388 if (this->IsInMemkind)
1397 delete this->Arrays;
1405 if (!this->StorageIs64Bit)
1410 this->Arrays->Int64->~VisitState();
1411 delete this->Arrays->Int64;
1413 this->StorageIs64Bit =
false;
1422 if (this->StorageIs64Bit)
1427 this->Arrays->Int32->~VisitState();
1428 delete this->Arrays->Int32;
1430 this->StorageIs64Bit =
true;
1436 bool Is64Bit()
const {
return this->StorageIs64Bit; }
1441 assert(!this->StorageIs64Bit);
1442 return *this->Arrays->Int32;
1447 assert(!this->StorageIs64Bit);
1448 return *this->Arrays->Int32;
1454 assert(this->StorageIs64Bit);
1455 return *this->Arrays->Int64;
1460 assert(this->StorageIs64Bit);
1461 return *this->Arrays->Int64;
1467 ArraySwitch* Arrays;
1468 bool StorageIs64Bit;
1469 bool IsInMemkind =
false;
1484template <
typename ArrayT>
1487 return this->Offsets->GetNumberOfValues() - 1;
1490template <
typename ArrayT>
1493 return static_cast<vtkIdType>(this->Offsets->GetValue(cellId));
1496template <
typename ArrayT>
1499 return static_cast<vtkIdType>(this->Offsets->GetValue(cellId + 1));
1502template <
typename ArrayT>
1505 return this->GetEndOffset(cellId) - this->GetBeginOffset(cellId);
1508template <
typename ArrayT>
1512 return vtk::DataArrayValueRange<1>(
1513 this->GetConnectivity(), this->GetBeginOffset(cellId), this->GetEndOffset(cellId));
1515VTK_ABI_NAMESPACE_END
1519VTK_ABI_NAMESPACE_BEGIN
1524 template <
typename CellStateT>
1527 using ValueType =
typename CellStateT::ValueType;
1528 auto* conn = state.GetConnectivity();
1529 auto* offsets = state.GetOffsets();
1531 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1533 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1537 conn->InsertNextValue(
static_cast<ValueType
>(pts[i]));
1544 template <
typename CellStateT>
1547 using ValueType =
typename CellStateT::ValueType;
1548 auto* conn = state.GetConnectivity();
1549 auto* offsets = state.GetOffsets();
1551 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1553 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1562 template <
typename CellStateT>
1565 using ValueType =
typename CellStateT::ValueType;
1567 auto* offsets = state.GetOffsets();
1568 const ValueType cellBegin = offsets->GetValue(offsets->GetMaxId() - 1);
1569 offsets->SetValue(offsets->GetMaxId(),
static_cast<ValueType
>(cellBegin + npts));
1575 template <
typename CellStateT>
1578 return state.GetCellSize(cellId);
1584 template <
typename CellStateT>
1587 using ValueType =
typename CellStateT::ValueType;
1589 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1590 const vtkIdType endOffset = state.GetEndOffset(cellId);
1591 const vtkIdType cellSize = endOffset - beginOffset;
1592 const auto cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1597 for (ValueType i = 0; i < cellSize; ++i)
1599 idPtr[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1603 template <
typename CellStateT>
1607 using ValueType =
typename CellStateT::ValueType;
1609 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1610 const vtkIdType endOffset = state.GetEndOffset(cellId);
1611 cellSize = endOffset - beginOffset;
1612 const ValueType* cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1615 for (
vtkIdType i = 0; i < cellSize; ++i)
1617 cellPoints[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1623 template <
typename CellStateT>
1627 using ValueType =
typename CellStateT::ValueType;
1628 using ArrayType =
typename CellStateT::ArrayType;
1630 static constexpr bool ValueTypeCompat = CellStateT::ValueTypeIsSameAsIdType;
1631 static constexpr bool ArrayTypeCompat = std::is_base_of<AOSArrayType, ArrayType>::value;
1634 static constexpr bool value = ValueTypeCompat && ArrayTypeCompat;
1637 template <
typename CellStateT>
1638 typename std::enable_if<CanShareConnPtr<CellStateT>::value,
void>::type
operator()(
1642 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1643 const vtkIdType endOffset = state.GetEndOffset(cellId);
1644 cellSize = endOffset - beginOffset;
1646 cellPoints =
reinterpret_cast<vtkIdType*
>(state.GetConnectivity()->GetPointer(beginOffset));
1649 template <
typename CellStateT>
1650 typename std::enable_if<!CanShareConnPtr<CellStateT>::value,
void>::type
operator()(
1654 using ValueType =
typename CellStateT::ValueType;
1656 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1657 const vtkIdType endOffset = state.GetEndOffset(cellId);
1658 cellSize = endOffset - beginOffset;
1659 const ValueType* cellConnectivity = state.GetConnectivity()->GetPointer(beginOffset);
1664 for (
vtkIdType i = 0; i < cellSize; ++i)
1666 tempPtr[i] =
static_cast<vtkIdType>(cellConnectivity[i]);
1675 template <
typename CellStateT>
1679 cells.GetConnectivity()->GetValue(cells.GetBeginOffset(cellId) + cellPointIndex));
1685 template <
typename CellStateT>
1688 state.GetOffsets()->Reset();
1689 state.GetConnectivity()->Reset();
1690 state.GetOffsets()->InsertNextValue(0);
1694VTK_ABI_NAMESPACE_END
1697VTK_ABI_NAMESPACE_BEGIN
1707 if (this->TraversalCellId < this->GetNumberOfCells())
1709 this->GetCellAtId(this->TraversalCellId, npts, pts);
1710 ++this->TraversalCellId;
1781 using ValueType =
typename ArrayType64::ValueType;
1786 using ValueType =
typename ArrayType32::ValueType;
1818VTK_ABI_NAMESPACE_END
Array-Of-Structs implementation of vtkGenericDataArray.
abstract object to represent cell connectivity
virtual vtkIdType GetNumberOfCells() const =0
Get the number of cells in the array.
void GetCellAtId(vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints)
Return the point ids for the cell at cellId.
Encapsulate traversal logic for vtkCellArray.
object to represent cell connectivity
vtkIdType GetCellSize(vtkIdType cellId) const override
Return the size of the cell at cellId.
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 IsHomogeneous() override
Check if all cells have the same number of vertices.
vtkIdType GetOffset(vtkIdType cellId) override
Get the offset (into the connectivity) for a specified cell id.
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.
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.:
static void SetDefaultStorageIs64Bit(bool val)
Control the default internal storage size.
void DeepCopy(vtkAbstractCellArray *ca) override
Perform a deep copy (no reference counting) of the given cell array.
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...
void ShallowCopy(vtkAbstractCellArray *ca) override
Shallow copy ca into this cell array.
vtkIdType GetNumberOfOffsets() const override
Get the number of elements in the offsets array.
vtkIdType GetTraversalCellId()
Get/Set the current cellId for traversal.
void Visit(Functor &&functor, Args &&... args)
vtkTypeInt32Array ArrayType32
vtkIdType GetNumberOfCells() const override
Get the number of cells in the array.
ArrayType64 * GetConnectivityArray64()
Return the array used to store the point ids that define the cells' connectivity.
vtkIdType GetNumberOfConnectivityIds() const override
Get the size of the connectivity array that stores the point ids.
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.
vtkTypeInt64Array ArrayType64
vtkIdType TraversalCellId
bool IsStorageShareable() const override
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.
static bool DefaultStorageIs64Bit
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 GetCellAtId(vtkIdType cellId, vtkIdType &cellSize, vtkIdType const *&cellPoints, vtkIdList *ptIds) override
Return the point ids for the cell at cellId.
void InsertCellPoint(vtkIdType id)
Used in conjunction with InsertNextCell(npts) to add another point to the list of cells.
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 Initialize() override
Free any memory and reset to an empty state.
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.
void Visit(Functor &&functor, Args &&... args) const
ArrayType64 * GetOffsetsArray64()
Return the array used to store cell offsets.
void SetOffset(vtkIdType cellId, vtkIdType offset)
Set the offset (into the connectivity) for a specified cell id.
bool ConvertToSmallestStorage()
Convert internal data structures to use 32- or 64-bit storage.
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.
vtkIdType GetCellPointAtId(vtkIdType cellId, vtkIdType cellPointIndex) const
Return the point id at cellPointIndex for the cell at cellId.
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.
static bool GetDefaultStorageIs64Bit()
Control the default internal storage size.
int GetMaxCellSize() override
Returns the size of the largest cell.
vtkIdType InsertNextCell(vtkCell *cell)
Insert a cell object.
virtual void SetNumberOfCells(vtkIdType)
Set the number of cells in the array.
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.
vtkIdType GetSize()
Get the size of the allocated connectivity array.
vtkTypeList::Create< ArrayType32, ArrayType64 > StorageArrayList
List of possible array types used for storage.
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
Allocate and hold a VTK object.
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...
Hold a reference to a vtkObjectBase instance.
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()
vtkIdType operator()(CellStateT &cells, vtkIdType cellId, vtkIdType cellPointIndex) const
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)
void operator()(CellStateT &state, const vtkIdType cellId, vtkIdType &cellSize, vtkIdType *cellPoints)
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(...)
#define VTK_MARSHALMANUAL