-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2023 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "VTKViewer_ConvexTool.h"
#include "VTKViewer_ArcBuilder.h"
-#include <vtkSmartPointer.h>
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkGenericCell.h>
#include <vtkPolyData.h>
#include <vtkPolygon.h>
#include <vtkPyramid.h>
+#include <vtkSmartPointer.h>
+#include <vtkStaticCellLinks.h>
#include <vtkStructuredGrid.h>
#include <vtkTetra.h>
#include <vtkUnsignedCharArray.h>
#include <vtkUnstructuredGrid.h>
+#include <vtkVersion.h>
#include <vtkVoxel.h>
#include <vtkWedge.h>
-#include <vtkVersion.h>
#include <algorithm>
#include <iterator>
#endif
///////////////////////////////////////////////////////////////////////////////////////////////
-vtkStandardNewMacro(VTKViewer_GeometryFilter);
+#include "Qtx.h"
+
+vtkStandardNewMacro(VTKViewer_GeometryFilter)
VTKViewer_GeometryFilter
::VTKViewer_GeometryFilter():
myAppendCoincident3D(0),
myMaxArcAngle(2),
myIsBuildArc(false)
-{}
+{
+ static int forceDelegateToVtk = -1;
+ if ( forceDelegateToVtk < 0 )
+ {
+ QString env = Qtx::getenv( "SALOME_ACTOR_DO_NOT_DELEGATE_TO_VTK" );
+ forceDelegateToVtk = (int)(env != "1");
+ }
+ delegateToVtk = forceDelegateToVtk > 0;
+}
VTKViewer_GeometryFilter
static inline bool toShowEdge( vtkIdType id1, vtkIdType id2, vtkIdType cellId, vtkUnstructuredGrid* input )
{
// return true if the given cell is the 1st among cells including the edge
- vtkCellLinks * links = input->GetCellLinks();
+ vtkStaticCellLinks * links = static_cast<vtkStaticCellLinks *>(input->GetCellLinks());
if ( !links ) {
input->BuildLinks();
- links = input->GetCellLinks();
+ links = static_cast<vtkStaticCellLinks *>(input->GetCellLinks());
}
if ( id1 < id2 )
std::swap( id1, id2 );
vtkIdType *cells = links->GetCells( id1 );
// among cells, look for a cell including the edge
- vtkIdType *cellPts, npts, iCell = 0;
+ vtkIdType npts, iCell = 0;
+ vtkIdType const *cellPts;
bool found = false;
while ( !found )
{
return ( cells[iCell] == cellId );
}
+//------------------------------------------------------------------------------
+// Excluded faces are defined here.
+struct vtkExcludedFaces
+{
+ vtkStaticCellLinksTemplate<vtkIdType>* Links;
+ vtkExcludedFaces()
+ : Links(nullptr)
+ {
+ }
+ ~vtkExcludedFaces() { delete this->Links; }
+};
+
+// fill myVTK2ObjIds to get the correspondence between vtk ids (displayed edges and faces
+// computed in vtkGeometryFilter::UnstructuredGridExecute) and original cell ids (mesh cells)
+void VTKViewer_GeometryFilter
+::FillVTK2ObjIds(vtkPolyData *output) {
+
+ vtkDataArray* vtkOriginalCellIds = output->GetCellData()->GetArray("vtkOriginalCellIds");
+
+ if (vtkOriginalCellIds == nullptr)
+ throw std::runtime_error("vtkOriginalCellIds is null. Something is wrong.");
+
+ const vtkIdType numTuples = vtkOriginalCellIds->GetNumberOfTuples();
+ myVTK2ObjIds.resize(numTuples);
+
+ // copy ids of vtkOriginalCellIds into myVTK2ObjIds
+ vtkIdTypeArray *vtkOriginalCellIdsInt(vtkIdTypeArray::SafeDownCast(vtkOriginalCellIds));
+ vtkIdType* origIds(vtkOriginalCellIdsInt->GetPointer(0));
+ myVTK2ObjIds.assign(origIds, origIds+numTuples);
+}
+
int
VTKViewer_GeometryFilter
::RequestData(
vtkInformationVector **inputVector,
vtkInformationVector *outputVector)
{
+
// get the info objects
- vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
+ vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
// get the input and ouptut
vtkDataSet *input = vtkDataSet::SafeDownCast(
- inInfo->Get(vtkDataObject::DATA_OBJECT()));
+ inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkPolyData *output = vtkPolyData::SafeDownCast(
- outInfo->Get(vtkDataObject::DATA_OBJECT()));
+ outInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkIdType numCells=input->GetNumberOfCells();
+ vtkIdType numPts = input->GetNumberOfPoints();
- if (numCells == 0)
+ if (numPts == 0 || numCells == 0)
{
- return 0;
+ return 0;
}
- if (input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID){
- return this->UnstructuredGridExecute(input, output, outInfo);
- }else
- return Superclass::RequestData(request,inputVector,outputVector);
+#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9,0,0)
+ if (delegateToVtk)
+ {
- return 1;
+ // get the info objects excluded faces
+ vtkInformation* excInfo = inputVector[1]->GetInformationObject(0);
+
+ vtkExcludedFaces exc; // Will delete exc->Links when goes out of scope
+ vtkPolyData* excFaces = nullptr;
+ if (excInfo)
+ {
+ excFaces = vtkPolyData::SafeDownCast(excInfo->Get(vtkDataObject::DATA_OBJECT()));
+ vtkCellArray* excPolys = excFaces->GetPolys();
+ if (excPolys->GetNumberOfCells() > 0)
+ {
+ exc.Links = new vtkStaticCellLinksTemplate<vtkIdType>;
+ exc.Links->ThreadedBuildLinks(numPts, excPolys->GetNumberOfCells(), excPolys);
+ }
+ }
+
+ switch (input->GetDataObjectType())
+ {
+ case VTK_POLY_DATA:
+ return this->vtkGeometryFilter::PolyDataExecute(input, output, excFaces);
+ case VTK_UNSTRUCTURED_GRID:
+ {
+ vtkUnstructuredGrid* inputUnstructured = static_cast<vtkUnstructuredGrid*>(input);
+
+ // The "info", is passed to provide information about the unstructured grid. This
+ // is done to avoid repeated evaluations of "info" in the vtkGeometryFilter and
+ // the vtkDataSetSurfaceFilter (which vtkGeometryFilter might delagate to in case
+ // of nonlinear data).
+ vtkGeometryFilterHelper* info = vtkGeometryFilterHelper::CharacterizeUnstructuredGrid(inputUnstructured);
+
+ bool NotFitForDelegation = false;
+ if ( vtkUnsignedCharArray* types = inputUnstructured->GetCellTypesArray() )
+ {
+ std::set<vtkIdType> ElementsNotFitToDelegate;
+
+ // All quadratic, biquadratic, and triquadratic elements not fit for delegation
+ // as SMESH has special display with curves mode for meshes containing these
+ // elements hence such meshes are not handled by "vtkGeometryFilter" instead
+ // the native VTKViewer_GeometryFilter::UnstructuredGridExecute is used.
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_EDGE );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_TRIANGLE );
+ ElementsNotFitToDelegate.insert( VTK_BIQUADRATIC_TRIANGLE );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_QUAD );
+ ElementsNotFitToDelegate.insert( VTK_BIQUADRATIC_QUAD );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_POLYGON );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_TETRA );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_HEXAHEDRON );
+ ElementsNotFitToDelegate.insert( VTK_TRIQUADRATIC_HEXAHEDRON );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_WEDGE );
+ ElementsNotFitToDelegate.insert( VTK_BIQUADRATIC_QUADRATIC_WEDGE );
+ ElementsNotFitToDelegate.insert( VTK_QUADRATIC_PYRAMID );
+
+ for ( int i = 0; i < types->GetNumberOfTuples() && !NotFitForDelegation; ++i )
+ NotFitForDelegation = ElementsNotFitToDelegate.count( types->GetValue(i) );
+ }
+ if ( NotFitForDelegation )
+ return this->UnstructuredGridExecute(input, output, outInfo);
+ else
+ {
+ int ret;
+ if ( myStoreMapping ) {
+ // pass through cell ids to get original cell ids
+ this->PassThroughCellIds = true;
+ ret = this->vtkGeometryFilter::UnstructuredGridExecute(input, output, info, excFaces);
+ FillVTK2ObjIds(output);
+ }
+ else {
+ // no need to get original cell ids
+ this->PassThroughCellIds = false;
+ ret = this->vtkGeometryFilter::UnstructuredGridExecute(input, output, info, excFaces);
+ }
+ return ret;
+ }
+ }
+ }
+
+ return this->vtkGeometryFilter::DataSetExecute(input, output, excFaces);
+ }
+ else // !delegateToVtk
+#endif
+ {
+ if (input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID){
+ return this->UnstructuredGridExecute(input, output, outInfo);
+ }
+ else {
+ return Superclass::RequestData(request,inputVector,outputVector);
+ }
+ }
}
int
VTKViewer_GeometryFilter
::UnstructuredGridExecute(vtkDataSet *dataSetInput,
vtkPolyData *output,
- vtkInformation *outInfo)
+ vtkInformation */*outInfo*/)
{
vtkUnstructuredGrid *input= (vtkUnstructuredGrid *)dataSetInput;
vtkCellArray *Connectivity = input->GetCells();
}
vtkIdType cellId;
- int i;
+ vtkIdType i;
int allVisible;
vtkIdType npts = 0;
- vtkIdType *pts = 0;
+ vtkIdType const *pts = 0;
vtkPoints *p = input->GetPoints();
vtkIdType numCells=input->GetNumberOfCells();
vtkPointData *pd = input->GetPointData();
char *cellVis;
vtkIdType newCellId;
- int faceId, *faceVerts, *edgeVerts, numFacePts;
+ int faceId, numFacePts;
double *x;
vtkIdType PixelConvert[4];
// Change the type from int to vtkIdType in order to avoid compilation errors while using VTK
quad1D2DTypes.insert( VTK_BIQUADRATIC_QUAD );
quad1D2DTypes.insert( VTK_QUADRATIC_POLYGON );
- for ( int i = 0; i < types->GetNumberOfTuples() && !hasQuad1D2D; ++i )
+ for ( auto i = 0; i < types->GetNumberOfTuples() && !hasQuad1D2D; ++i )
hasQuad1D2D = quad1D2DTypes.count( types->GetValue(i) );
}
buildArcs = hasQuad1D2D;
// Loop over all cells now that visibility is known
// (Have to compute visibility first for 3D cell boundaries)
- int progressInterval = numCells/20 + 1;
+ vtkIdType progressInterval = numCells/20 + 1;
TMapOfVectorId aDimension2VTK2ObjIds;
if ( myStoreMapping )
aDimension2VTK2ObjIds.resize( 3 ); // max dimension is 2
aCellType = VTK_LINE;
for ( int edgeID = 0; edgeID < 6; ++edgeID )
{
- edgeVerts = vtkTetra::GetEdgeArray( edgeID );
+ const vtkIdType *edgeVerts = vtkTetra::GetEdgeArray( edgeID );
if ( toShowEdge( pts[edgeVerts[0]], pts[edgeVerts[1]], cellId, input ))
{
aNewPts[0] = pts[edgeVerts[0]];
{
#ifdef SHOW_COINCIDING_3D_PAL21924
faceIdsTmp->SetNumberOfIds( npts );
- for ( int ai = 0; ai < npts; ai++ )
+ for ( auto ai = 0; ai < npts; ai++ )
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
#endif
for (faceId = 0; faceId < 4; faceId++)
{
faceIds->Reset();
- faceVerts = vtkTetra::GetFaceArray(faceId);
+ const vtkIdType *faceVerts = vtkTetra::GetFaceArray(faceId);
faceIds->InsertNextId(pts[faceVerts[0]]);
faceIds->InsertNextId(pts[faceVerts[1]]);
faceIds->InsertNextId(pts[faceVerts[2]]);
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
#ifdef SHOW_COINCIDING_3D_PAL21924
bool process = nbNeighbors <= 0;
#else
aCellType = VTK_LINE;
for ( int edgeID = 0; edgeID < 12; ++edgeID )
{
- edgeVerts = vtkVoxel::GetEdgeArray( edgeID );
+ const vtkIdType *edgeVerts = vtkVoxel::GetEdgeArray( edgeID );
if ( toShowEdge( pts[edgeVerts[0]], pts[edgeVerts[1]], cellId, input ))
{
aNewPts[0] = pts[edgeVerts[0]];
{
#ifdef SHOW_COINCIDING_3D_PAL21924
faceIdsTmp->SetNumberOfIds( npts );
- for ( int ai = 0; ai < npts; ai++ )
+ for ( auto ai = 0; ai < npts; ai++ )
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
#endif
for (faceId = 0; faceId < 6; faceId++)
{
faceIds->Reset();
- faceVerts = vtkVoxel::GetFaceArray(faceId);
+ const vtkIdType*faceVerts = vtkVoxel::GetFaceArray(faceId);
faceIds->InsertNextId(pts[faceVerts[0]]);
faceIds->InsertNextId(pts[faceVerts[1]]);
faceIds->InsertNextId(pts[faceVerts[2]]);
aCellType = VTK_QUAD;
numFacePts = 4;
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
#ifdef SHOW_COINCIDING_3D_PAL21924
bool process = nbNeighbors <= 0;
#else
aCellType = VTK_LINE;
for ( int edgeID = 0; edgeID < 12; ++edgeID )
{
- edgeVerts = vtkHexahedron::GetEdgeArray( edgeID );
+ const vtkIdType *edgeVerts = vtkHexahedron::GetEdgeArray( edgeID );
if ( toShowEdge( pts[edgeVerts[0]], pts[edgeVerts[1]], cellId, input ))
{
aNewPts[0] = pts[edgeVerts[0]];
{
#ifdef SHOW_COINCIDING_3D_PAL21924
faceIdsTmp->SetNumberOfIds( npts );
- for ( int ai = 0; ai < npts; ai++ )
+ for ( auto ai = 0; ai < npts; ai++ )
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
#endif
for (faceId = 0; faceId < 6; faceId++)
{
faceIds->Reset();
- faceVerts = vtkHexahedron::GetFaceArray(faceId);
+ const vtkIdType *faceVerts = vtkHexahedron::GetFaceArray(faceId);
faceIds->InsertNextId(pts[faceVerts[0]]);
faceIds->InsertNextId(pts[faceVerts[1]]);
faceIds->InsertNextId(pts[faceVerts[2]]);
faceIds->InsertNextId(pts[faceVerts[3]]);
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
#ifdef SHOW_COINCIDING_3D_PAL21924
bool process = nbNeighbors <= 0;
#else
aCellType = VTK_LINE;
for ( int edgeID = 0; edgeID < 9; ++edgeID )
{
- edgeVerts = vtkWedge::GetEdgeArray( edgeID );
+ const vtkIdType *edgeVerts = vtkWedge::GetEdgeArray( edgeID );
if ( toShowEdge( pts[edgeVerts[0]], pts[edgeVerts[1]], cellId, input ))
{
aNewPts[0] = pts[edgeVerts[0]];
for (faceId = 0; faceId < 5; faceId++)
{
faceIds->Reset();
- faceVerts = vtkWedge::GetFaceArray(faceId);
+ const vtkIdType *faceVerts = vtkWedge::GetFaceArray(faceId);
faceIds->InsertNextId(pts[faceVerts[0]]);
faceIds->InsertNextId(pts[faceVerts[1]]);
faceIds->InsertNextId(pts[faceVerts[2]]);
numFacePts = 4;
}
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
#ifdef SHOW_COINCIDING_3D_PAL21924
bool process = nbNeighbors <= 0;
#else
aCellType = VTK_LINE;
for ( int edgeID = 0; edgeID < 18; ++edgeID )
{
- edgeVerts = vtkHexagonalPrism::GetEdgeArray( edgeID );
+ const vtkIdType *edgeVerts = vtkHexagonalPrism::GetEdgeArray( edgeID );
if ( toShowEdge( pts[edgeVerts[0]], pts[edgeVerts[1]], cellId, input ))
{
aNewPts[0] = pts[edgeVerts[0]];
{
#ifdef SHOW_COINCIDING_3D_PAL21924
faceIdsTmp->SetNumberOfIds( npts );
- for ( int ai = 0; ai < npts; ai++ )
+ for ( auto ai = 0; ai < npts; ai++ )
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
#endif
for (faceId = 0; faceId < 8; faceId++)
{
- faceVerts = vtkHexagonalPrism::GetFaceArray(faceId);
+ const vtkIdType *faceVerts = vtkHexagonalPrism::GetFaceArray(faceId);
faceIds->Reset();
faceIds->InsertNextId(pts[faceVerts[0]]);
faceIds->InsertNextId(pts[faceVerts[1]]);
numFacePts = 6;
}
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
#ifdef SHOW_COINCIDING_3D_PAL21924
bool process = nbNeighbors <= 0;
#else
if ( myShowInside )
{
aCellType = VTK_LINE;
- for ( int edgeID = 0; edgeID < 8; ++edgeID )
+ for ( auto edgeID = 0; edgeID < 8; ++edgeID )
{
- edgeVerts = vtkPyramid::GetEdgeArray( edgeID );
+ const vtkIdType *edgeVerts = vtkPyramid::GetEdgeArray( edgeID );
if ( toShowEdge( pts[edgeVerts[0]], pts[edgeVerts[1]], cellId, input ))
{
aNewPts[0] = pts[edgeVerts[0]];
{
#ifdef SHOW_COINCIDING_3D_PAL21924
faceIdsTmp->SetNumberOfIds( npts );
- for ( int ai = 0; ai < npts; ai++ )
+ for ( auto ai = 0; ai < npts; ai++ )
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
#endif
for (faceId = 0; faceId < 5; faceId++)
{
faceIds->Reset();
- faceVerts = vtkPyramid::GetFaceArray(faceId);
+ const vtkIdType *faceVerts = vtkPyramid::GetFaceArray(faceId);
faceIds->InsertNextId(pts[faceVerts[0]]);
faceIds->InsertNextId(pts[faceVerts[1]]);
faceIds->InsertNextId(pts[faceVerts[2]]);
numFacePts = 4;
}
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
#ifdef SHOW_COINCIDING_3D_PAL21924
bool process = nbNeighbors <= 0;
#else
case VTK_POLYHEDRON:
{
vtkIdType nFaces = 0;
- vtkIdType* ptIds = 0;
- int idp = 0;
+ const vtkIdType* ptIds = 0;
+ vtkIdType idp = 0;
input->GetFaceStream(cellId, nFaces, ptIds);
#ifdef SHOW_COINCIDING_3D_PAL21924
if ( !myShowInside )
{
faceIds->Reset();
numFacePts = ptIds[idp];
- int pt0 = ++idp;
+ vtkIdType pt0 = ++idp;
for (i = 0; i < numFacePts; i++)
{
faceIds->InsertNextId(ptIds[idp + i]);
default:aCellType = VTK_POLYGON;
}
input->GetCellNeighbors(cellId, faceIds, cellIds);
- int nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - cellIdsTmp->GetNumberOfIds();
if ( myShowInside && nbNeighbors > 0 && cellId < cellIds->GetId(0) )
continue; // don't add twice same internal face in wireframe mode
#ifdef SHOW_COINCIDING_3D_PAL21924
case VTK_QUADRATIC_HEXAHEDRON:
case VTK_TRIQUADRATIC_HEXAHEDRON:
case VTK_QUADRATIC_WEDGE:
+ case VTK_BIQUADRATIC_QUADRATIC_WEDGE:
case VTK_QUADRATIC_PYRAMID:
if(!myIsWireframeMode)
if ( cell->GetCellDimension() == 1 ) {
vtkIdType arcResult = -1;
if(myIsBuildArc) {
- arcResult = Build1DArc(cellId, input, output, pts, myMaxArcAngle);
+ arcResult = Build1DArc(cellId, input, output, const_cast<vtkIdType *>(pts), myMaxArcAngle);
newCellId = arcResult;
}
#ifdef SHOW_COINCIDING_3D_PAL21924
if ( !myShowInside )
{
- int npts1 = 0;
+ vtkIdType npts1 = 0;
switch (aCellType ){
- case VTK_QUADRATIC_TETRA: npts1 = 4; break;
- case VTK_QUADRATIC_HEXAHEDRON: npts1 = 8; break;
- case VTK_TRIQUADRATIC_HEXAHEDRON: npts1 = 8; break;
- case VTK_QUADRATIC_WEDGE: npts1 = 6; break;
- case VTK_QUADRATIC_PYRAMID: npts1 = 5; break;
+ case VTK_QUADRATIC_TETRA: npts1 = 4; break;
+ case VTK_QUADRATIC_HEXAHEDRON: npts1 = 8; break;
+ case VTK_TRIQUADRATIC_HEXAHEDRON: npts1 = 8; break;
+ case VTK_QUADRATIC_WEDGE: npts1 = 6; break;
+ case VTK_BIQUADRATIC_QUADRATIC_WEDGE: npts1 = 6; break;
+ case VTK_QUADRATIC_PYRAMID: npts1 = 5; break;
}
faceIdsTmp->SetNumberOfIds( npts1 );
if ( npts1 > 0 ) {
- for (int ai=0; ai<npts1; ai++)
+ for (auto ai=0; ai<npts1; ai++)
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
}
#endif
aCellType = VTK_TRIANGLE;
numFacePts = 3;
- int nbNeighbors = 0;
- for (int j=0; j < cell->GetNumberOfFaces(); j++)
+ vtkIdType nbNeighbors = 0;
+ for (auto j=0; j < cell->GetNumberOfFaces(); j++)
{
vtkCell *face = cell->GetFace(j);
if ( !myShowInside ) {
switch(aCellType) {
case VTK_QUADRATIC_EDGE:
{
- vtkIdType arcResult =-1;
+ vtkIdType arcResult = -1;
if(myIsBuildArc) {
- arcResult = Build1DArc(cellId, input, output, pts,myMaxArcAngle);
- newCellId = arcResult;
+ arcResult = Build1DArc(cellId, input, output, const_cast<vtkIdType *>(pts), myMaxArcAngle);
+ newCellId = arcResult;
}
if(!myIsBuildArc || arcResult == -1) {
aCellType = VTK_POLY_LINE;
}
case VTK_QUADRATIC_TETRA:
case VTK_QUADRATIC_WEDGE:
+ case VTK_BIQUADRATIC_QUADRATIC_WEDGE:
case VTK_TRIQUADRATIC_HEXAHEDRON:
case VTK_QUADRATIC_HEXAHEDRON:
case VTK_QUADRATIC_PYRAMID:
}
else
{
- int nbCoincident = 0;
+ vtkIdType nbCoincident = 0;
#ifdef SHOW_COINCIDING_3D_PAL21924
- int nbPnt = npts - cell->GetNumberOfEdges();
+ vtkIdType nbPnt = npts - cell->GetNumberOfEdges();
faceIdsTmp->SetNumberOfIds( nbPnt );
- for ( int ai = 0; ai < nbPnt; ai++ )
+ for ( auto ai = 0; ai < nbPnt; ai++ )
faceIdsTmp->SetId( ai, pts[ai] );
input->GetCellNeighbors(cellId, faceIdsTmp, cellIdsTmp);
nbCoincident = cellIdsTmp->GetNumberOfIds();
{
vtkCell * face = cell->GetFace( faceId );
input->GetCellNeighbors( cellId, face->GetPointIds(), cellIds );
- int nbNeighbors = cellIds->GetNumberOfIds() - nbCoincident;
+ vtkIdType nbNeighbors = cellIds->GetNumberOfIds() - nbCoincident;
if ( nbNeighbors <= 0 )
{
- int nbEdges = face->GetNumberOfPoints() / 2;
- for ( int edgeId = 0; edgeId < nbEdges; ++edgeId )
+ vtkIdType nbEdges = face->GetNumberOfPoints() / 2;
+ for ( auto edgeId = 0; edgeId < nbEdges; ++edgeId )
{
vtkIdType p1 = ( edgeId ); // corner
vtkIdType p2 = ( edgeId + nbEdges ); // medium
VTKViewer_GeometryFilter
::InsertId( const vtkIdType theCellId,
const vtkIdType theCellType,
- TVectorId& theVTK2ObjIds,
+ TVectorId& /*theVTK2ObjIds*/,
TMapOfVectorId& theDimension2VTK2ObjIds )
{
//theVTK2ObjIds.push_back( theCellId );
}
-vtkIdType VTKViewer_GeometryFilter::GetElemObjId( int theVtkID )
+vtkIdType VTKViewer_GeometryFilter::GetElemObjId( vtkIdType theVtkID )
{
- if( theVtkID < 0 || theVtkID >= (int)myVTK2ObjIds.size() )
+ if( theVtkID < 0 || theVtkID >= (vtkIdType)myVTK2ObjIds.size() )
return -1;
return myVTK2ObjIds[theVtkID];
}
}
case VTK_QUADRATIC_POLYGON:
{
- int nbP = aCell->GetNumberOfPoints();
+ vtkIdType nbP = aCell->GetNumberOfPoints();
std::vector< Pnt > pVec( nbP + 2 );
- for ( int i = 0; i < nbP/2; ++i )
+ for ( auto i = 0; i < nbP/2; ++i )
{
pVec[i*2 + 0] = CreatePnt( aCell, inputScalars, i );
pVec[i*2 + 1] = CreatePnt( aCell, inputScalars, i + nbP/2 );
pVec[ nbP ] = pVec[ 0 ];
pVec[ nbP+1 ] = pVec[ 1 ];
- for ( int i = 0; i < nbP; i += 2 )
+ for ( auto i = 0; i < nbP; i += 2 )
{
VTKViewer_ArcBuilder aBuilder( pVec[i], pVec[i+1], pVec[i+2], myMaxArcAngle );
aCollection.push_back( aBuilder.GetPoints() );
vtkIdType aTriangleId;
vtkPolygon *aPlg = vtkPolygon::New();
- std::map<int, double> aPntId2ScalarValue;
+ std::map<vtkIdType, double> aPntId2ScalarValue;
aNbPoints = MergevtkPoints(aCollection, aScalarCollection, aPlg->GetPoints(), aPntId2ScalarValue, aNewPoints);
aPlg->GetPointIds()->SetNumberOfIds(aNbPoints);
aPlg->Delete();
}
else {
- std::map<int, double> aPntId2ScalarValue;
+ std::map<vtkIdType, double> aPntId2ScalarValue;
aNbPoints = MergevtkPoints(aCollection, aScalarCollection, output->GetPoints(), aPntId2ScalarValue, aNewPoints);
if(outputScalars)
for(vtkIdType i = 0; i < aNbPoints; i++)
