# encoding: utf-8 # module vtkmodules.vtkCommonDataModel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms class vtkGenericAdaptorCell(__vtkmodules_vtkCommonCore.vtkObject): """ vtkGenericAdaptorCell - defines cell interface Superclass: vtkObject In VTK, spatial-temporal data is defined in terms of a dataset which is composed of cells. The cells are topological entities over which an interpolation field is applied. Cells are defined in terms of a topology (e.g., vertices, lines, triangles, polygons, tetrahedra, etc.), points that instantiate the geometry of the cells, and interpolation fields (in the general case one interpolation field is for geometry, the other is for attribute data associated with the cell). Currently most algorithms in VTK use vtkCell and vtkDataSet, which make assumptions about the nature of datasets, cells, and attributes. In particular, this abstraction assumes that cell interpolation functions are linear, or products of linear functions. Further, VTK implements most of the interpolation functions. This implementation starts breaking down as the complexity of the interpolation (or basis) functions increases. vtkGenericAdaptorCell addresses these issues by providing more general abstraction for cells. It also adopts modern C++ practices including using iterators. The vtkGenericAdaptorCell is designed to fit within the adaptor framework; meaning that it is meant to adapt VTK to external simulation systems (see the GenericFiltering/README.html). Please note that most cells are defined in terms of other cells (the boundary cells). They are also defined in terms of points, which are not the same as vertices (vertices are a 0-D cell; points represent a position in space). Another important concept is the notion of DOFNodes. These concept supports cell types with complex interpolation functions. For example, higher-order p-method finite elements may have different functions on each of their topological features (edges, faces, region). The coefficients of these polynomial functions are associated with DOFNodes. (There is a single DOFNode for each topological feature.) Note that from this perspective, points are used to establish the topological form of the cell; mid-side nodes and such are considered DOFNodes. @sa vtkGenericDataSet """ def Clip(self, value, f, attributes, tess, insideOut, locator, connectivity, outPd, outCd, internalPd, secondaryPd, secondaryCd): # real signature unknown; restored from __doc__ """ Clip(self, value:float, f:vtkImplicitFunction, attributes:vtkGenericAttributeCollection, tess:vtkGenericCellTessellator, insideOut:int, locator:vtkIncrementalPointLocator, connectivity:vtkCellArray, outPd:vtkPointData, outCd:vtkCellData, internalPd:vtkPointData, secondaryPd:vtkPointData, secondaryCd:vtkCellData) -> None C++: virtual void Clip(double value, vtkImplicitFunction *f, vtkGenericAttributeCollection *attributes, vtkGenericCellTessellator *tess, int insideOut, vtkIncrementalPointLocator *locator, vtkCellArray *connectivity, vtkPointData *outPd, vtkCellData *outCd, vtkPointData *internalPd, vtkPointData *secondaryPd, vtkCellData *secondaryCd) Cut (or clip) the current cell with respect to the contour defined by the `value' or the implicit function `f' of the scalar attribute (`attributes->GetActiveAttribute()',`attributes->GetActiveComponent()' ). If `f' exists, `value' is not used. The output is the part of the current cell which is inside the contour. The output is a set of zero, one or more cells of the same topological dimension as the current cell. Normally, cell points whose scalar value is greater than "value" are considered inside. If `insideOut' is on, this is reversed. Clipping interpolates the `attributes->GetNumberOfattributesToInterpolate()' attributes `attributes->GetAttributesToInterpolate()'. `locator', `connectivity', `outPd' and `outCd' are cumulative data arrays over cell iterations: they store the result of each call to Clip(): - `locator' is a points list that merges points as they are inserted (i.e., prevents duplicates). - `connectivity' is an array of generated cells - `outPd' is an array of interpolated point data along the edge (if not-nullptr) - `outCd' is an array of copied cell data of the current cell (if not-nullptr) `internalPd', `secondaryPd' and `secondaryCd' are initialized by the filter that call it from `attributes'. - `internalPd' stores the re ... [Truncated] """ pass def Contour(self, values, f, attributes, tess, locator, verts, lines, polys, outPd, outCd, internalPd, secondaryPd, secondaryCd): # real signature unknown; restored from __doc__ """ Contour(self, values:vtkContourValues, f:vtkImplicitFunction, attributes:vtkGenericAttributeCollection, tess:vtkGenericCellTessellator, locator:vtkIncrementalPointLocator, verts:vtkCellArray, lines:vtkCellArray, polys:vtkCellArray, outPd:vtkPointData, outCd:vtkCellData, internalPd:vtkPointData, secondaryPd:vtkPointData, secondaryCd:vtkCellData) -> None C++: virtual void Contour(vtkContourValues *values, vtkImplicitFunction *f, vtkGenericAttributeCollection *attributes, vtkGenericCellTessellator *tess, vtkIncrementalPointLocator *locator, vtkCellArray *verts, vtkCellArray *lines, vtkCellArray *polys, vtkPointData *outPd, vtkCellData *outCd, vtkPointData *internalPd, vtkPointData *secondaryPd, vtkCellData *secondaryCd) Generate a contour (contouring primitives) for each `values' or with respect to an implicit function `f'. Contouring is performed on the scalar attribute (`attributes->GetActiveAttribute()' `attributes->GetActiveComponent()'). Contouring interpolates the `attributes->GetNumberOfattributesToInterpolate()' attributes `attributes->GetAttributesToInterpolate()'. The `locator', `verts', `lines', `polys', `outPd' and `outCd' are cumulative data arrays over cell iterations: they store the result of each call to Contour(): - `locator' is a points list that merges points as they are inserted (i.e., prevents duplicates). - `verts' is an array of generated vertices - `lines' is an array of generated lines - `polys' is an array of generated polygons - `outPd' is an array of interpolated point data along the edge (if not-nullptr) - `outCd' is an array of copied cell data of the current cell (if not-nullptr) `internalPd', `secondaryPd' and `secondaryCd' are initialized by the filter that call it from `attributes'. - `internalPd' stores the result of the tessellation pass: the higher-order cell is tessellated into linear sub-cells. - `secondaryPd' and `secondaryCd' are used internally as i ... [Truncated] """ pass def CountEdgeNeighbors(self, sharing, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ CountEdgeNeighbors(self, sharing:[int, ...]) -> None C++: virtual void CountEdgeNeighbors(int *sharing) """ pass def CountNeighbors(self, boundary): # real signature unknown; restored from __doc__ """ CountNeighbors(self, boundary:vtkGenericAdaptorCell) -> int C++: virtual int CountNeighbors(vtkGenericAdaptorCell *boundary) Number of cells (dimension>boundary->GetDimension()) of the dataset that share the boundary `boundary' of `this'. `this' IS NOT INCLUDED. \pre boundary_exists: boundary!=0 \pre real_boundary: !boundary->IsInDataSet() \pre cell_of_the_dataset: IsInDataSet() \pre boundary: HasBoundary(boundary) \post positive_result: result>=0 """ return 0 def Derivatives(self, subId, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Derivatives(self, subId:int, pcoords:[float, float, float], attribute:vtkGenericAttribute, derivs:[float, ...]) -> None C++: virtual void Derivatives(int subId, double pcoords[3], vtkGenericAttribute *attribute, double *derivs) Compute derivatives `derivs' of the attribute `attribute' (from its values at the corner points of the cell) given sub-cell `subId' (0 means primary cell) and parametric coordinates `pcoords'. Derivatives are in the x-y-z coordinate directions for each data value. \pre positive_subId: subId>=0 \pre clamped_pcoords: (0<=pcoords[0])&&(pcoords[0]<=1)&&(0<=pcoords[1]) &&(pcoords[1]<=1)&&(0<=pcoords[2])%%(pcoords[2]<=1) \pre attribute_exists: attribute!=0 \pre derivs_exists: derivs!=0 \pre valid_size: sizeof(derivs)>=attribute->GetNumberOfComponents()*3 """ pass def EvaluateLocation(self, subId, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ EvaluateLocation(self, subId:int, pcoords:[float, float, float], x:[float, float, float]) -> None C++: virtual void EvaluateLocation(int subId, double pcoords[3], double x[3]) Determine the global coordinates `x' from sub-cell `subId' and parametric coordinates `pcoords' in the cell. \pre positive_subId: subId>=0 \pre clamped_pcoords: (0<=pcoords[0])&&(pcoords[0]<=1)&&(0<=pcoords[1]) &&(pcoords[1]<=1)&&(0<=pcoords[2])&&(pcoords[2]<=1) """ pass def EvaluatePosition(self, x, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ EvaluatePosition(self, x:(float, float, float), closestPoint:[float, ...], subId:int, pcoords:[float, float, float], dist2:float) -> int C++: virtual int EvaluatePosition(const double x[3], double *closestPoint, int &subId, double pcoords[3], double &dist2) Is `x' inside the current cell? It also evaluates parametric coordinates `pcoords', sub-cell id `subId' (0 means primary cell), distance squared to the sub-cell in `dist2' and closest corner point `closestPoint'. `dist2' and `closestPoint' are not evaluated if `closestPoint'==0. If a numerical error occurred, -1 is returned and all other results should be ignored. \post valid_result: result==-1 || result==0 || result==1 \post positive_distance: result!=-1 implies (closestPoint!=0 implies dist2>=0) """ pass def GetAttributeOrder(self, a): # real signature unknown; restored from __doc__ """ GetAttributeOrder(self, a:vtkGenericAttribute) -> int C++: virtual int GetAttributeOrder(vtkGenericAttribute *a) Return the interpolation order of attribute `a' on the cell (may differ by cell). \pre a_exists: a!=0 \post positive_result: result>=0 """ return 0 def GetBoundaryIterator(self, boundaries, dim=-1): # real signature unknown; restored from __doc__ """ GetBoundaryIterator(self, boundaries:vtkGenericCellIterator, dim:int=-1) -> None C++: virtual void GetBoundaryIterator( vtkGenericCellIterator *boundaries, int dim=-1) Return the `boundaries' cells of dimension `dim' (or all dimensions less than GetDimension() if -1) that are part of the boundary of the cell. \pre valid_dim_range: (dim==-1) || ((dim>=0)&&(dim None C++: virtual void GetBounds(double bounds[6]) GetBounds(self) -> Pointer C++: virtual double *GetBounds() Compute the bounding box of the current cell in `bounds' in global coordinates. THREAD SAFE """ pass def GetDimension(self): # real signature unknown; restored from __doc__ """ GetDimension(self) -> int C++: virtual int GetDimension() Return the topological dimension of the current cell. \post valid_result: result>=0 && result<=3 """ return 0 def GetEdgeArray(self, edgeId): # real signature unknown; restored from __doc__ """ GetEdgeArray(self, edgeId:int) -> Pointer C++: virtual const vtkIdType *GetEdgeArray(vtkIdType edgeId) Return the ids of the vertices defining edge `edgeId'. Ids are related to the cell, not to the dataset. \pre valid_dimension: this->GetDimension()>=2 \pre valid_edgeId_range: edgeId>=0 && edgeIdGetNumberOfBoundaries(1) \post result_exists: result!=0 \post valid_size: sizeof(result)==2 ote The return type changed. It used to be int*, it is now const vtkIdType*. This is so ids are unified between vtkCell and vtkPoints. """ pass def GetFaceArray(self, faceId): # real signature unknown; restored from __doc__ """ GetFaceArray(self, faceId:int) -> Pointer C++: virtual const vtkIdType *GetFaceArray(vtkIdType faceId) Return the ids of the vertices defining face `faceId'. Ids are related to the cell, not to the dataset. \pre is_3d: this->GetDimension()==3 \pre valid_faceId_range: faceId>=0 && faceIdGetNumberOfBoundaries(2) \post result_exists: result!=0 \post valid_size: sizeof(result)>=GetNumberOfVerticesOnFace(faceId) ote The return type changed. It used to be int*, it is now const vtkIdType*. This is so ids are unified between vtkCell and vtkPoints, and so vtkCell ids can be used as inputs in algorithms such as vtkPolygon::ComputeNormal. """ pass def GetGeometryOrder(self): # real signature unknown; restored from __doc__ """ GetGeometryOrder(self) -> int C++: virtual int GetGeometryOrder() Return the interpolation order of the geometry. \post positive_result: result>=0 """ return 0 def GetHighestOrderAttribute(self, ac): # real signature unknown; restored from __doc__ """ GetHighestOrderAttribute(self, ac:vtkGenericAttributeCollection) -> int C++: virtual int GetHighestOrderAttribute( vtkGenericAttributeCollection *ac) Return the index of the first point centered attribute with the highest order in `ac'. \pre ac_exists: ac!=0 \post valid_result: result>=-1 && resultGetNumberOfAttributes() """ return 0 def GetId(self): # real signature unknown; restored from __doc__ """ GetId(self) -> int C++: virtual vtkIdType GetId() Unique identification number of the cell over the whole data set. This unique key may not be contiguous. """ return 0 def GetLength2(self): # real signature unknown; restored from __doc__ """ GetLength2(self) -> float C++: virtual double GetLength2() Return the bounding box diagonal squared of the current cell. \post positive_result: result>=0 """ return 0.0 def GetNeighbors(self, boundary, neighbors): # real signature unknown; restored from __doc__ """ GetNeighbors(self, boundary:vtkGenericAdaptorCell, neighbors:vtkGenericCellIterator) -> None C++: virtual void GetNeighbors(vtkGenericAdaptorCell *boundary, vtkGenericCellIterator *neighbors) Put into `neighbors' the cells (dimension>boundary->GetDimension()) of the dataset that share the boundary `boundary' with this cell. `this' IS NOT INCLUDED. \pre boundary_exists: boundary!=0 \pre real_boundary: !boundary->IsInDataSet() \pre cell_of_the_dataset: IsInDataSet() \pre boundary: HasBoundary(boundary) \pre neighbors_exist: neighbors!=0 """ pass def GetNumberOfBoundaries(self, dim=-1): # real signature unknown; restored from __doc__ """ GetNumberOfBoundaries(self, dim:int=-1) -> int C++: virtual int GetNumberOfBoundaries(int dim=-1) Return the number of boundaries of dimension `dim' (or all dimensions greater than 0 and less than GetDimension() if -1) of the cell. When dim is -1, the number of vertices is not included in the count because vertices are a special case: a vertex will have at most a single field value associated with it; DOF nodes may have an arbitrary number of field values associated with them. \pre valid_dim_range: (dim==-1) || ((dim>=0)&&(dim=0 """ return 0 def GetNumberOfDOFNodes(self): # real signature unknown; restored from __doc__ """ GetNumberOfDOFNodes(self) -> int C++: virtual int GetNumberOfDOFNodes() Accumulated number of DOF nodes of the current cell. A DOF node is a component of cell with a given topological dimension. e.g.: a triangle has 4 DOF: 1 face and 3 edges. An hexahedron has 19 DOF: 1 region, 6 faces, and 12 edges. * The number of vertices is not included in the * count because vertices are a special case: a vertex will have * at most a single field value associated with it; DOF nodes may have * an arbitrary number of field values associated with them. * \post valid_result: result==GetNumberOfBoundaries(-1)+1 """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfPoints(self): # real signature unknown; restored from __doc__ """ GetNumberOfPoints(self) -> int C++: virtual int GetNumberOfPoints() Return the number of corner points that compose the cell. \post positive_result: result>=0 """ return 0 def GetNumberOfVerticesOnFace(self, faceId): # real signature unknown; restored from __doc__ """ GetNumberOfVerticesOnFace(self, faceId:int) -> int C++: virtual int GetNumberOfVerticesOnFace(int faceId) Return the number of vertices defining face `faceId'. \pre is_3d: this->GetDimension()==3 \pre valid_faceId_range: faceId>=0 && faceIdGetNumberOfBoundaries(2) \post positive_result: && result>0 """ return 0 def GetParametricCenter(self, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetParametricCenter(self, pcoords:[float, float, float]) -> int C++: virtual int GetParametricCenter(double pcoords[3]) Get the center of the current cell (in parametric coordinates) and place it in `pcoords'. If the current cell is a composite, the return value is the sub-cell id that the center is in. \post valid_result: (result>=0) && (IsPrimary() implies result==0) """ pass def GetParametricCoords(self): # real signature unknown; restored from __doc__ """ GetParametricCoords(self) -> Pointer C++: virtual double *GetParametricCoords() Return a contiguous array of parametric coordinates of the corrner points defining the current cell. In other words, (px,py,pz, px,py,pz, etc..) The coordinates are ordered consistent with the definition of the point ordering for the cell. Note that 3D parametric coordinates are returned no matter what the topological dimension of the cell. \post valid_result_exists: ((IsPrimary()) && (result!=0)) || ((!IsPrimary()) && (result==0)) result!=0 implies sizeof(result)==GetNumberOfPoints() """ pass def GetParametricDistance(self, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetParametricDistance(self, pcoords:(float, float, float)) -> float C++: virtual double GetParametricDistance(const double pcoords[3]) Return the distance of the parametric coordinate `pcoords' to the current cell. If inside the cell, a distance of zero is returned. This is used during picking to get the correct cell picked. (The tolerance will occasionally allow cells to be picked who are not really intersected "inside" the cell.) \post positive_result: result>=0 """ pass def GetPointIds(self, id, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetPointIds(self, id:[int, ...]) -> None C++: virtual void GetPointIds(vtkIdType *id) Put into `id' the list of the dataset points that define the corner points of the cell. \pre id_exists: id!=0 \pre valid_size: sizeof(id)==GetNumberOfPoints(); """ pass def GetPointIterator(self, it): # real signature unknown; restored from __doc__ """ GetPointIterator(self, it:vtkGenericPointIterator) -> None C++: virtual void GetPointIterator(vtkGenericPointIterator *it) Return the points of cell into `it'. \pre it_exists: it!=0 """ pass def GetType(self): # real signature unknown; restored from __doc__ """ GetType(self) -> int C++: virtual int GetType() Return the type of the current cell. \post (result==VTK_HIGHER_ORDER_EDGE)|| (result==VTK_HIGHER_ORDER_TRIANGLE)|| (result==VTK_HIGHER_ORDER_TETRAHEDRON) """ return 0 def InterpolateTuple(self, a, pcoords, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ InterpolateTuple(self, a:vtkGenericAttribute, pcoords:[float, float, float], val:[float, ...]) -> None C++: virtual void InterpolateTuple(vtkGenericAttribute *a, double pcoords[3], double *val) InterpolateTuple(self, c:vtkGenericAttributeCollection, pcoords:[float, float, float], val:[float, ...]) -> None C++: virtual void InterpolateTuple( vtkGenericAttributeCollection *c, double pcoords[3], double *val) Interpolate the attribute `a' at local position `pcoords' of the cell into `val'. \pre a_exists: a!=0 \pre a_is_point_centered: a->GetCentering()==vtkPointCentered \pre clamped_point: pcoords[0]>=0 && pcoords[0]<=1 && pcoords[1]>=0 && pcoords[1]<=1 && pcoords[2]>=0 && pcoords[2]<=1 \pre val_exists: val!=0 \pre valid_size: sizeof(val)==a->GetNumberOfComponents() """ pass def IntersectWithLine(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ IntersectWithLine(self, p1:[float, float, float], p2:[float, float, float], tol:float, t:float, x:[float, float, float], pcoords:[float, float, float], subId:int) -> int C++: virtual int IntersectWithLine(double p1[3], double p2[3], double tol, double &t, double x[3], double pcoords[3], int &subId) Is there an intersection between the current cell and the ray (`p1',`p2') according to a tolerance `tol'? If true, `x' is the global intersection, `t' is the parametric coordinate for the line, `pcoords' are the parametric coordinates for cell. `subId' is the sub-cell where the intersection occurs. \pre positive_tolerance: tol>0 """ pass def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsAttributeLinear(self, a): # real signature unknown; restored from __doc__ """ IsAttributeLinear(self, a:vtkGenericAttribute) -> int C++: vtkTypeBool IsAttributeLinear(vtkGenericAttribute *a) Does the attribute `a' have a non-linear interpolation? \pre a_exists: a!=0 \post definition: result==(GetAttributeOrder()==1) """ return 0 def IsFaceOnBoundary(self, faceId): # real signature unknown; restored from __doc__ """ IsFaceOnBoundary(self, faceId:int) -> int C++: virtual int IsFaceOnBoundary(vtkIdType faceId) Is the face `faceId' of the current cell on the exterior boundary of the dataset? \pre 3d: GetDimension()==3 """ return 0 def IsGeometryLinear(self): # real signature unknown; restored from __doc__ """ IsGeometryLinear(self) -> int C++: int IsGeometryLinear() Does the cell have a non-linear interpolation for the geometry? \post definition: result==(GetGeometryOrder()==1) """ return 0 def IsInDataSet(self): # real signature unknown; restored from __doc__ """ IsInDataSet(self) -> int C++: virtual int IsInDataSet() Does `this' a cell of a dataset? (otherwise, it is a boundary cell) """ return 0 def IsOnBoundary(self): # real signature unknown; restored from __doc__ """ IsOnBoundary(self) -> int C++: virtual int IsOnBoundary() Is the cell on the exterior boundary of the dataset? \pre 2d: GetDimension()==2 """ return 0 def IsPrimary(self): # real signature unknown; restored from __doc__ """ IsPrimary(self) -> int C++: virtual int IsPrimary() Is the cell primary (i.e. not composite) ? """ return 0 def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewCellIterator(self): # real signature unknown; restored from __doc__ """ NewCellIterator(self) -> vtkGenericCellIterator C++: virtual vtkGenericCellIterator *NewCellIterator() Create an empty cell iterator. The user is responsible for deleting it. \post result_exists: result!=0 """ return vtkGenericCellIterator def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkGenericAdaptorCell C++: vtkGenericAdaptorCell *NewInstance() """ return vtkGenericAdaptorCell def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkGenericAdaptorCell C++: static vtkGenericAdaptorCell *SafeDownCast(vtkObjectBase *o) """ return vtkGenericAdaptorCell def Tessellate(self, attributes, tess, points, locator, cellArray, internalPd, pd, cd, types): # real signature unknown; restored from __doc__ """ Tessellate(self, attributes:vtkGenericAttributeCollection, tess:vtkGenericCellTessellator, points:vtkPoints, locator:vtkIncrementalPointLocator, cellArray:vtkCellArray, internalPd:vtkPointData, pd:vtkPointData, cd:vtkCellData, types:vtkUnsignedCharArray) -> None C++: virtual void Tessellate( vtkGenericAttributeCollection *attributes, vtkGenericCellTessellator *tess, vtkPoints *points, vtkIncrementalPointLocator *locator, vtkCellArray *cellArray, vtkPointData *internalPd, vtkPointData *pd, vtkCellData *cd, vtkUnsignedCharArray *types) Tessellate the cell if it is not linear or if at least one attribute of `attributes' is not linear. The output are linear cells of the same dimension than the cell. If the cell is linear and all attributes are linear, the output is just a copy of the current cell. `points', `cellArray', `pd' and `cd' are cumulative output data arrays over cell iterations: they store the result of each call to Tessellate(). `internalPd' is initialized by the calling filter and stores the result of the tessellation. If it is not null, `types' is filled with the types of the linear cells. `types' is null when it is called from vtkGenericGeometryFilter and not null when it is called from vtkGenericDatasetTessellator. \pre attributes_exist: attributes!=0 \pre tessellator_exists: tess!=0 \pre points_exist: points!=0 \pre cellArray_exists: cellArray!=0 \pre internalPd_exists: internalPd!=0 \pre pd_exist: pd!=0 \pre cd_exists: cd!=0 """ pass def TriangulateFace(self, attributes, tess, index, points, locator, cellArray, internalPd, pd, cd): # real signature unknown; restored from __doc__ """ TriangulateFace(self, attributes:vtkGenericAttributeCollection, tess:vtkGenericCellTessellator, index:int, points:vtkPoints, locator:vtkIncrementalPointLocator, cellArray:vtkCellArray, internalPd:vtkPointData, pd:vtkPointData, cd:vtkCellData) -> None C++: virtual void TriangulateFace( vtkGenericAttributeCollection *attributes, vtkGenericCellTessellator *tess, int index, vtkPoints *points, vtkIncrementalPointLocator *locator, vtkCellArray *cellArray, vtkPointData *internalPd, vtkPointData *pd, vtkCellData *cd) Tessellate face `index' of the cell. See Tessellate() for further explanations. \pre cell_is_3d: GetDimension()==3 \pre attributes_exist: attributes!=0 \pre tessellator_exists: tess!=0 \pre valid_face: index>=0 \pre points_exist: points!=0 \pre cellArray_exists: cellArray!=0 \pre internalPd_exists: internalPd!=0 \pre pd_exist: pd!=0 \pre cd_exists: cd!=0 """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkGenericAdaptorCell', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'GetId': , 'IsInDataSet': , 'GetType': , 'GetDimension': , 'GetGeometryOrder': , 'IsGeometryLinear': , 'GetAttributeOrder': , 'GetHighestOrderAttribute': , 'IsAttributeLinear': , 'IsPrimary': , 'GetNumberOfPoints': , 'GetNumberOfBoundaries': , 'GetNumberOfDOFNodes': , 'GetPointIterator': , 'NewCellIterator': , 'GetBoundaryIterator': , 'CountNeighbors': , 'CountEdgeNeighbors': , 'GetNeighbors': , 'EvaluatePosition': , 'EvaluateLocation': , 'InterpolateTuple': , 'Contour': , 'Clip': , 'IntersectWithLine': , 'Derivatives': , 'GetBounds': , 'GetLength2': , 'GetParametricCenter': , 'GetParametricDistance': , 'GetParametricCoords': , 'Tessellate': , 'IsFaceOnBoundary': , 'IsOnBoundary': , 'GetPointIds': , 'TriangulateFace': , 'GetFaceArray': , 'GetNumberOfVerticesOnFace': , 'GetEdgeArray': , '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkGenericAdaptorCell - defines cell interface\\n\\nSuperclass: vtkObject\\n\\nIn VTK, spatial-temporal data is defined in terms of a dataset which\\nis composed of cells. The cells are topological entities over which\\nan interpolation field is applied. Cells are defined in terms of a\\ntopology (e.g., vertices, lines, triangles, polygons, tetrahedra,\\netc.), points that instantiate the geometry of the cells, and\\ninterpolation fields (in the general case one interpolation field is\\nfor geometry, the other is for attribute data associated with the\\ncell).\\n\\nCurrently most algorithms in VTK use vtkCell and vtkDataSet, which\\nmake assumptions about the nature of datasets, cells, and attributes.\\nIn particular, this abstraction assumes that cell interpolation\\nfunctions are linear, or products of linear functions. Further, VTK\\nimplements most of the interpolation functions. This implementation\\nstarts breaking down as the complexity of the interpolation (or\\nbasis) functions increases.\\n\\nvtkGenericAdaptorCell addresses these issues by providing more\\ngeneral abstraction for cells. It also adopts modern C++ practices\\nincluding using iterators. The vtkGenericAdaptorCell is designed to\\nfit within the adaptor framework; meaning that it is meant to adapt\\nVTK to external simulation systems (see the\\nGenericFiltering/README.html).\\n\\nPlease note that most cells are defined in terms of other cells (the\\nboundary cells). They are also defined in terms of points, which are\\nnot the same as vertices (vertices are a 0-D cell; points represent a\\nposition in space).\\n\\nAnother important concept is the notion of DOFNodes. These concept\\nsupports cell types with complex interpolation functions. For\\nexample, higher-order p-method finite elements may have different\\nfunctions on each of their topological features (edges, faces,\\nregion). The coefficients of these polynomial functions are\\nassociated with DOFNodes. (There is a single DOFNode for each\\ntopological feature.) Note that from this perspective, points are\\nused to establish the topological form of the cell; mid-side nodes\\nand such are considered DOFNodes.\\n\\n@sa\\nvtkGenericDataSet\\n\\n'})" __vtkname__ = 'vtkGenericAdaptorCell'