135#ifndef vtkCellArray_h
136#define vtkCellArray_h
138#include "vtkCommonDataModelModule.h"
144#include "vtkFeatures.h"
146#include "vtkTypeInt32Array.h"
147#include "vtkTypeInt64Array.h"
151#include <initializer_list>
152#include <type_traits>
175#define VTK_CELL_ARRAY_V2
229 return this->AllocateExact(sz, sz) ? 1 : 0;
243 return this->AllocateExact(numCells, numCells * maxCellSize);
378 void SetData(vtkTypeInt32Array* offsets, vtkTypeInt32Array* connectivity);
379 void SetData(vtkTypeInt64Array* offsets, vtkTypeInt64Array* connectivity);
498 return this->GetOffsetsArray64();
502 return this->GetOffsetsArray32();
519 return this->GetConnectivityArray64();
523 return this->GetConnectivityArray32();
549 void InitTraversal();
598 VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());
631 return this->InsertNextCell(
static_cast<vtkIdType>(cell.size()), cell.begin());
652 void UpdateCellCount(
int npts);
692 return this->ReplaceCellAtId(cellId,
static_cast<vtkIdType>(cell.size()), cell.begin());
767 unsigned long GetActualMemorySize() const;
775 template <
typename ArrayT>
780 using CellRangeType =
decltype(vtk::DataArrayValueRange<1>(std::declval<ArrayType>()));
787 static constexpr bool ValueTypeIsSameAsIdType = std::is_integral<ValueType>::value &&
813 this->Offsets->InsertNextValue(0);
816 this->IsInMemkind =
true;
820 void*
operator new(
size_t nSize)
823#ifdef VTK_USE_MEMKIND
830 void operator delete(
void* p)
832#ifdef VTK_USE_MEMKIND
853 bool IsInMemkind =
false;
857 template <
typename Functor,
typename... Args>
858 using GetReturnType =
decltype(
859 std::declval<Functor>()(std::declval<VisitState<ArrayType32>&>(), std::declval<Args>()...));
861 template <
typename Functor,
typename... Args>
862 struct ReturnsVoid : std::is_same<GetReturnType<Functor, Args...>, void>
936 template <
typename Functor,
typename... Args,
937 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
938 void Visit(Functor&& functor, Args&&... args)
956 template <
typename Functor,
typename... Args,
957 typename =
typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
958 void Visit(Functor&& functor, Args&&... args)
const
976 template <
typename Functor,
typename... Args,
977 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
978 GetReturnType<Functor, Args...>
Visit(Functor&& functor, Args&&... args)
995 template <
typename Functor,
typename... Args,
996 typename =
typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
997 GetReturnType<Functor, Args...>
Visit(Functor&& functor, Args&&... args)
const
1080 VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries());
1175#ifdef VTK_USE_MEMKIND
1183#ifdef VTK_USE_64BIT_IDS
1186 this->StorageIs64Bit =
true;
1191 this->StorageIs64Bit =
false;
1194#ifdef VTK_USE_MEMKIND
1197 this->IsInMemkind =
true;
1200 (void)this->IsInMemkind;
1206 if (this->StorageIs64Bit)
1208 this->Arrays->Int64->~VisitState();
1209 delete this->Arrays->Int64;
1213 this->Arrays->Int32->~VisitState();
1214 delete this->Arrays->Int32;
1216#ifdef VTK_USE_MEMKIND
1217 if (this->IsInMemkind)
1226 delete this->Arrays;
1234 if (!this->StorageIs64Bit)
1239 this->Arrays->Int64->~VisitState();
1240 delete this->Arrays->Int64;
1242 this->StorageIs64Bit =
false;
1251 if (this->StorageIs64Bit)
1256 this->Arrays->Int32->~VisitState();
1257 delete this->Arrays->Int32;
1259 this->StorageIs64Bit =
true;
1265 bool Is64Bit()
const {
return this->StorageIs64Bit; }
1270 assert(!this->StorageIs64Bit);
1271 return *this->Arrays->Int32;
1276 assert(!this->StorageIs64Bit);
1277 return *this->Arrays->Int32;
1283 assert(this->StorageIs64Bit);
1284 return *this->Arrays->Int64;
1289 assert(this->StorageIs64Bit);
1290 return *this->Arrays->Int64;
1296 ArraySwitch* Arrays;
1297 bool StorageIs64Bit;
1298 bool IsInMemkind =
false;
1312template <
typename ArrayT>
1315 return this->Offsets->GetNumberOfValues() - 1;
1318template <
typename ArrayT>
1321 return static_cast<vtkIdType>(this->Offsets->GetValue(cellId));
1324template <
typename ArrayT>
1327 return static_cast<vtkIdType>(this->Offsets->GetValue(cellId + 1));
1330template <
typename ArrayT>
1333 return this->GetEndOffset(cellId) - this->GetBeginOffset(cellId);
1336template <
typename ArrayT>
1340 return vtk::DataArrayValueRange<1>(
1341 this->GetConnectivity(), this->GetBeginOffset(cellId), this->GetEndOffset(cellId));
1350 template <
typename CellStateT>
1353 using ValueType =
typename CellStateT::ValueType;
1354 auto* conn = state.GetConnectivity();
1355 auto* offsets = state.GetOffsets();
1357 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1359 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1363 conn->InsertNextValue(
static_cast<ValueType
>(pts[i]));
1370 template <
typename CellStateT>
1373 using ValueType =
typename CellStateT::ValueType;
1374 auto* conn = state.GetConnectivity();
1375 auto* offsets = state.GetOffsets();
1377 const vtkIdType cellId = offsets->GetNumberOfValues() - 1;
1379 offsets->InsertNextValue(
static_cast<ValueType
>(conn->GetNumberOfValues() + npts));
1388 template <
typename CellStateT>
1391 using ValueType =
typename CellStateT::ValueType;
1393 auto* offsets = state.GetOffsets();
1394 const ValueType cellBegin = offsets->GetValue(offsets->GetMaxId() - 1);
1395 offsets->SetValue(offsets->GetMaxId(),
static_cast<ValueType
>(cellBegin + npts));
1401 template <
typename CellStateT>
1404 return state.GetCellSize(cellId);
1410 template <
typename CellStateT>
1413 using ValueType =
typename CellStateT::ValueType;
1415 const auto cellPts = state.GetCellRange(cellId);
1420 for (ValueType ptId : cellPts)
1422 *idPtr++ =
static_cast<vtkIdType>(ptId);
1428 template <
typename CellStateT>
1432 using ValueType =
typename CellStateT::ValueType;
1433 using ArrayType =
typename CellStateT::ArrayType;
1435 static constexpr bool ValueTypeCompat = CellStateT::ValueTypeIsSameAsIdType;
1436 static constexpr bool ArrayTypeCompat = std::is_base_of<AOSArrayType, ArrayType>::value;
1439 static constexpr bool value = ValueTypeCompat && ArrayTypeCompat;
1442 template <
typename CellStateT>
1443 typename std::enable_if<CanShareConnPtr<CellStateT>::value,
void>::type
operator()(
1447 const vtkIdType beginOffset = state.GetBeginOffset(cellId);
1448 const vtkIdType endOffset = state.GetEndOffset(cellId);
1449 cellSize = endOffset - beginOffset;
1451 cellPoints =
reinterpret_cast<vtkIdType*
>(state.GetConnectivity()->GetPointer(beginOffset));
1454 template <
typename CellStateT>
1455 typename std::enable_if<!CanShareConnPtr<CellStateT>::value,
void>::type
operator()(
1459 using ValueType =
typename CellStateT::ValueType;
1461 const auto cellPts = state.GetCellRange(cellId);
1462 cellSize = cellPts.size();
1468 for (ValueType ptId : cellPts)
1470 *tempPtr++ =
static_cast<vtkIdType>(ptId);
1479 template <
typename CellStateT>
1482 state.GetOffsets()->Reset();
1483 state.GetConnectivity()->Reset();
1484 state.GetOffsets()->InsertNextValue(0);
1499 if (this->TraversalCellId < this->GetNumberOfCells())
1501 this->GetCellAtId(this->TraversalCellId, npts, pts);
1502 ++this->TraversalCellId;
1561 using ValueType =
typename ArrayType64::ValueType;
1566 using ValueType =
typename ArrayType32::ValueType;
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().
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.:
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)
vtkTypeInt32Array ArrayType32
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.
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.
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.
vtkIdType GetCellSize(const vtkIdType cellId) const
Return the size of the cell at cellId.
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
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(const vtkIdType i)
Get a pointer to a particular data index.
void SetNumberOfIds(const vtkIdType number)
Specify the number of ids for this object to hold.
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...
abstract base class for most VTK objects
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
static constexpr bool ValueTypeIsSameAsIdType
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, const 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(...)