X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_UnstructuredGrid.cxx;h=ef5d8959980fefe28c3ad592e3f39803dbd3cc6c;hp=5fe82a432a7cd65a17750e81df074b22c043cecf;hb=a274ade365bd0f0e19d56c577acc4a13aa1972a7;hpb=6bac08c1a81f34d3f21c550bd92f83654b2546a5 diff --git a/src/SMDS/SMDS_UnstructuredGrid.cxx b/src/SMDS/SMDS_UnstructuredGrid.cxx index 5fe82a432..ef5d89599 100644 --- a/src/SMDS/SMDS_UnstructuredGrid.cxx +++ b/src/SMDS/SMDS_UnstructuredGrid.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2010-2015 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2010-2021 CEA/DEN, EDF R&D, OPEN CASCADE // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public @@ -36,11 +36,8 @@ #include #include -using namespace std; - SMDS_CellLinks* SMDS_CellLinks::New() { - MESSAGE("SMDS_CellLinks::New"); return new SMDS_CellLinks(); } @@ -49,11 +46,56 @@ void SMDS_CellLinks::ResizeForPoint(vtkIdType vtkID) if ( vtkID > this->MaxId ) { this->MaxId = vtkID; - if ( vtkID >= this->Size ) + if ( vtkID >= this->Size ) vtkCellLinks::Resize( vtkID+SMDS_Mesh::chunkSize ); } } +void SMDS_CellLinks::BuildLinks(vtkDataSet *data, vtkCellArray *Connectivity, vtkUnsignedCharArray* types) +{ + // build links taking into account removed cells + + vtkIdType numPts = data->GetNumberOfPoints(); + vtkIdType j, cellId = 0; + unsigned short *linkLoc; + vtkIdType npts=0; + vtkIdType const *pts(nullptr); + vtkIdType loc = Connectivity->GetTraversalLocation(); + + // traverse data to determine number of uses of each point + cellId = 0; + for (Connectivity->InitTraversal(); + Connectivity->GetNextCell(npts,pts); cellId++) + { + if ( types->GetValue( cellId ) != VTK_EMPTY_CELL ) + for (j=0; j < npts; j++) + { + this->IncrementLinkCount(pts[j]); + } + } + + // now allocate storage for the links + this->AllocateLinks(numPts); + this->MaxId = numPts - 1; + + // fill out lists with references to cells + linkLoc = new unsigned short[numPts]; + memset(linkLoc, 0, numPts*sizeof(unsigned short)); + + cellId = 0; + for (Connectivity->InitTraversal(); + Connectivity->GetNextCell(npts,pts); cellId++) + { + if ( types->GetValue( cellId ) != VTK_EMPTY_CELL ) + for (j=0; j < npts; j++) + { + this->InsertCellReference(pts[j], (linkLoc[pts[j]])++, cellId); + } + } + delete [] linkLoc; + Connectivity->SetTraversalLocation(loc); +} + SMDS_CellLinks::SMDS_CellLinks() : vtkCellLinks() { @@ -65,7 +107,6 @@ SMDS_CellLinks::~SMDS_CellLinks() SMDS_UnstructuredGrid* SMDS_UnstructuredGrid::New() { - MESSAGE("SMDS_UnstructuredGrid::New"); return new SMDS_UnstructuredGrid(); } @@ -82,70 +123,52 @@ SMDS_UnstructuredGrid::~SMDS_UnstructuredGrid() { } -unsigned long SMDS_UnstructuredGrid::GetMTime() +vtkMTimeType SMDS_UnstructuredGrid::GetMTime() { - unsigned long mtime = vtkUnstructuredGrid::GetMTime(); - MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime); + vtkMTimeType mtime = vtkUnstructuredGrid::GetMTime(); return mtime; } -// OUV_PORTING_VTK6: seems to be useless -/* -void SMDS_UnstructuredGrid::Update() -{ - MESSAGE("SMDS_UnstructuredGrid::Update"); - return vtkUnstructuredGrid::Update(); -} -void SMDS_UnstructuredGrid::UpdateInformation() -{ - MESSAGE("SMDS_UnstructuredGrid::UpdateInformation"); - return vtkUnstructuredGrid::UpdateInformation(); -} -*/ vtkPoints* SMDS_UnstructuredGrid::GetPoints() { // TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010 - //MESSAGE("*********************** SMDS_UnstructuredGrid::GetPoints " << this->Points << " " << vtkUnstructuredGrid::GetPoints()); return this->Points; } -//#ifdef VTK_HAVE_POLYHEDRON int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *pts) { - if (type != VTK_POLYHEDRON) + if ( !this->Links ) // don't create Links until they are needed + { + return this->InsertNextCell(type, npts, pts); + } + + if ( type != VTK_POLYHEDRON ) return vtkUnstructuredGrid::InsertNextLinkedCell(type, npts, pts); // --- type = VTK_POLYHEDRON - //MESSAGE("InsertNextLinkedCell VTK_POLYHEDRON"); int cellid = this->InsertNextCell(type, npts, pts); - set setOfNodes; + std::set setOfNodes; setOfNodes.clear(); int nbfaces = npts; int i = 0; for (int nf = 0; nf < nbfaces; nf++) + { + int nbnodes = pts[i]; + i++; + for (int k = 0; k < nbnodes; k++) { - int nbnodes = pts[i]; + if ( setOfNodes.insert( pts[i] ).second ) + { + (static_cast< vtkCellLinks * >(this->Links.GetPointer()))->ResizeCellList( pts[i], 1 ); + (static_cast< vtkCellLinks * >(this->Links.GetPointer()))->AddCellReference( cellid, pts[i] ); + } i++; - for (int k = 0; k < nbnodes; k++) - { - //MESSAGE(" cell " << cellid << " face " << nf << " node " << pts[i]); - setOfNodes.insert(pts[i]); - i++; - } - } - - set::iterator it = setOfNodes.begin(); - for (; it != setOfNodes.end(); ++it) - { - //MESSAGE("reverse link for node " << *it << " cell " << cellid); - this->Links->ResizeCellList(*it, 1); - this->Links->AddCellReference(cellid, *it); } + } return cellid; } -//#endif void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh) { @@ -153,48 +176,84 @@ void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh) } void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int newNodeSize, - std::vector& idCellsOldToNew, int newCellSize) + std::vector& idCellsNewToOld, int newCellSize) { - MESSAGE("------------------------- SMDS_UnstructuredGrid::compactGrid " << newNodeSize << " " << newCellSize);//CHRONO(1); - int alreadyCopied = 0; + this->DeleteLinks(); - // --- if newNodeSize, create a new compacted vtkPoints + // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes" in SMDS numeration. + // We compact only if there were holes - vtkPoints *newPoints = vtkPoints::New(); - newPoints->SetDataType(VTK_DOUBLE); - newPoints->SetNumberOfPoints(newNodeSize); - if (newNodeSize) + int oldNodeSize = this->GetNumberOfPoints(); + bool updateNodes = ( oldNodeSize > newNodeSize ); + if ( true /*updateNodes*/ ) + { + // 21125: EDF 1233 SMESH: Degradation of precision in a test case for quadratic conversion + // Use double type for storing coordinates of nodes instead float. + vtkPoints *newPoints = vtkPoints::New(); + newPoints->SetDataType( VTK_DOUBLE ); + newPoints->SetNumberOfPoints( newNodeSize ); + + int i = 0, alreadyCopied = 0; + while ( i < oldNodeSize ) { - MESSAGE("-------------- compactGrid, newNodeSize " << newNodeSize); - // rnv: to fix bug "21125: EDF 1233 SMESH: Degradation of precision in a test case for quadratic conversion" - // using double type for storing coordinates of nodes instead float. - int oldNodeSize = idNodesOldToNew.size(); + // skip a hole if any + while ( i < oldNodeSize && idNodesOldToNew[i] < 0 ) + ++i; + int startBloc = i; + // look for a block end + while ( i < oldNodeSize && idNodesOldToNew[i] >= 0 ) + ++i; + int endBloc = i; + copyNodes(newPoints, idNodesOldToNew, alreadyCopied, startBloc, endBloc); + } + this->SetPoints(newPoints); + newPoints->Delete(); + } + else + { + this->Points->Squeeze(); + this->Points->Modified(); + } - int i = 0; - while ( i < oldNodeSize ) - { - // skip a hole if any - while ( i < oldNodeSize && idNodesOldToNew[i] < 0 ) - ++i; - int startBloc = i; - // look for a block end - while ( i < oldNodeSize && idNodesOldToNew[i] >= 0 ) - ++i; - int endBloc = i; - copyNodes(newPoints, idNodesOldToNew, alreadyCopied, startBloc, endBloc); - } - newPoints->Squeeze(); + // Compact cells if VTK IDs do not correspond to SMDS IDs or nodes compacted + + int oldCellSize = this->Types->GetNumberOfTuples(); + bool updateCells = ( updateNodes || newCellSize != oldCellSize ); + for ( int newID = 0, nbIDs = idCellsNewToOld.size(); newID < nbIDs && !updateCells; ++newID ) + updateCells = ( idCellsNewToOld[ newID ] != newID ); + + if ( false /*!updateCells*/ ) // no holes in elements + { + this->Connectivity->Squeeze(); + this->CellLocations->Squeeze(); + this->Types->Squeeze(); + if ( this->FaceLocations ) + { + this->FaceLocations->Squeeze(); + this->Faces->Squeeze(); } + this->Connectivity->Modified(); + return; + } + + if ((int) idNodesOldToNew.size() < oldNodeSize ) + { + idNodesOldToNew.reserve( oldNodeSize ); + for ( int i = idNodesOldToNew.size(); i < oldNodeSize; ++i ) + idNodesOldToNew.push_back( i ); + } // --- create new compacted Connectivity, Locations and Types - int oldCellSize = this->Types->GetNumberOfTuples(); + int newConnectivitySize = this->Connectivity->GetNumberOfConnectivityEntries(); + if ( newCellSize != oldCellSize ) + for ( int i = 0; i < oldCellSize - 1; ++i ) + if ( this->Types->GetValue( i ) == VTK_EMPTY_CELL ) + newConnectivitySize -= this->Connectivity->GetCellSize( i ); vtkCellArray *newConnectivity = vtkCellArray::New(); newConnectivity->Initialize(); - int oldCellDataSize = this->Connectivity->GetData()->GetSize(); - newConnectivity->Allocate(oldCellDataSize); - MESSAGE("oldCellSize="<< oldCellSize << " oldCellDataSize=" << oldCellDataSize); + newConnectivity->Allocate( newConnectivitySize ); vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New(); newTypes->Initialize(); @@ -204,162 +263,129 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n newLocations->Initialize(); newLocations->SetNumberOfValues(newCellSize); - // TODO some polyhedron may be huge (only in some tests) - vtkIdType tmpid[NBMAXNODESINCELL]; - vtkIdType *pointsCell = &tmpid[0]; // --- points id to fill a new cell - - alreadyCopied = 0; - int i = 0; - while ( i < oldCellSize ) - { - // skip a hole if any - while ( i < oldCellSize && this->Types->GetValue(i) == VTK_EMPTY_CELL ) - ++i; - int startBloc = i; - // look for a block end - while ( i < oldCellSize && this->Types->GetValue(i) != VTK_EMPTY_CELL ) - ++i; - int endBloc = i; - if ( endBloc > startBloc ) - copyBloc(newTypes, - idCellsOldToNew, idNodesOldToNew, - newConnectivity, newLocations, - pointsCell, alreadyCopied, - startBloc, endBloc); - } - newConnectivity->Squeeze(); + std::vector< vtkIdType > pointsCell(1024); // --- points id to fill a new cell - if (1/*newNodeSize*/) - { - MESSAGE("------- newNodeSize, setPoints"); - this->SetPoints(newPoints); - MESSAGE("NumberOfPoints: " << this->GetNumberOfPoints()); - } + copyBloc(newTypes, idCellsNewToOld, idNodesOldToNew, + newConnectivity, newLocations, pointsCell ); if (vtkDoubleArray* diameters = vtkDoubleArray::SafeDownCast( vtkDataSet::CellData->GetScalars() )) // Balls { - for (int oldCellID = 0; oldCellID < oldCellSize; oldCellID++) + vtkDoubleArray* newDiameters = vtkDoubleArray::New(); + newDiameters->SetNumberOfComponents(1); + for ( int newCellID = 0; newCellID < newCellSize; newCellID++ ) { - if (this->Types->GetValue(oldCellID) == VTK_EMPTY_CELL) - continue; - int newCellId = idCellsOldToNew[ oldCellID ]; - if (newTypes->GetValue(newCellId) == VTK_POLY_VERTEX) - diameters->SetValue( newCellId, diameters->GetValue( oldCellID )); + if ( newTypes->GetValue( newCellID ) == VTK_POLY_VERTEX ) + { + int oldCellID = idCellsNewToOld[ newCellID ]; + newDiameters->InsertValue( newCellID, diameters->GetValue( oldCellID )); + } + vtkDataSet::CellData->SetScalars( newDiameters ); } } if (this->FaceLocations) + { + vtkIdTypeArray *newFaceLocations = vtkIdTypeArray::New(); + newFaceLocations->Initialize(); + newFaceLocations->Allocate(newTypes->GetSize()); + vtkIdTypeArray *newFaces = vtkIdTypeArray::New(); + newFaces->Initialize(); + newFaces->Allocate(this->Faces->GetSize()); + for ( int newCellID = 0; newCellID < newCellSize; newCellID++ ) { - vtkIdTypeArray *newFaceLocations = vtkIdTypeArray::New(); - newFaceLocations->Initialize(); - newFaceLocations->Allocate(newTypes->GetSize()); - vtkIdTypeArray *newFaces = vtkIdTypeArray::New(); - newFaces->Initialize(); - newFaces->Allocate(this->Faces->GetSize()); - for (int i = 0; i < oldCellSize; i++) + if ( newTypes->GetValue( newCellID ) == VTK_POLYHEDRON ) + { + int oldCellId = idCellsNewToOld[ newCellID ]; + newFaceLocations->InsertNextValue( newFaces->GetMaxId()+1 ); + int oldFaceLoc = this->FaceLocations->GetValue( oldCellId ); + int nCellFaces = this->Faces->GetValue( oldFaceLoc++ ); + newFaces->InsertNextValue( nCellFaces ); + for ( int n = 0; n < nCellFaces; n++ ) { - if (this->Types->GetValue(i) == VTK_EMPTY_CELL) - continue; - int newCellId = idCellsOldToNew[i]; - if (newTypes->GetValue(newCellId) == VTK_POLYHEDRON) - { - newFaceLocations->InsertNextValue(newFaces->GetMaxId()+1); - int oldFaceLoc = this->FaceLocations->GetValue(i); - int nCellFaces = this->Faces->GetValue(oldFaceLoc++); - newFaces->InsertNextValue(nCellFaces); - for (int n=0; nFaces->GetValue(oldFaceLoc++); - newFaces->InsertNextValue(nptsInFace); - for (int k=0; kFaces->GetValue(oldFaceLoc++); - newFaces->InsertNextValue(idNodesOldToNew[oldpt]); - } - } - } - else - { - newFaceLocations->InsertNextValue(-1); - } + int nptsInFace = this->Faces->GetValue( oldFaceLoc++ ); + newFaces->InsertNextValue( nptsInFace ); + for ( int k = 0; k < nptsInFace; k++ ) + { + int oldpt = this->Faces->GetValue( oldFaceLoc++ ); + newFaces->InsertNextValue( idNodesOldToNew[ oldpt ]); + } } - newFaceLocations->Squeeze(); - newFaces->Squeeze(); - this->SetCells(newTypes, newLocations, newConnectivity, newFaceLocations, newFaces); - newFaceLocations->Delete(); - newFaces->Delete(); + } + else + { + newFaceLocations->InsertNextValue(-1); + } } + newFaceLocations->Squeeze(); + newFaces->Squeeze(); + this->SetCells( newTypes, newLocations, newConnectivity, newFaceLocations, newFaces ); + this->CellLocations = newLocations; + newFaceLocations->Delete(); + newFaces->Delete(); + } else { - this->SetCells(newTypes, newLocations, newConnectivity, FaceLocations, Faces); + this->SetCells( newTypes, newLocations, newConnectivity, FaceLocations, Faces ); + this->CellLocations = newLocations; } - newPoints->Delete(); newTypes->Delete(); newLocations->Delete(); newConnectivity->Delete(); - this->BuildLinks(); } -void SMDS_UnstructuredGrid::copyNodes(vtkPoints *newPoints, std::vector& idNodesOldToNew, int& alreadyCopied, - int start, int end) +void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints, + std::vector& /*idNodesOldToNew*/, + int& alreadyCopied, + int start, + int end) { - MESSAGE("copyNodes " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start); void *target = newPoints->GetVoidPointer(3 * alreadyCopied); void *source = this->Points->GetVoidPointer(3 * start); int nbPoints = end - start; if (nbPoints > 0) - { - memcpy(target, source, 3 * sizeof(double) * nbPoints); - for (int j = start; j < end; j++) - idNodesOldToNew[j] = alreadyCopied++; // old vtkId --> new vtkId - } + { + memcpy(target, source, 3 * sizeof(double) * nbPoints); + alreadyCopied += nbPoints; + } } -void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes, - std::vector& idCellsOldToNew, - std::vector& idNodesOldToNew, - vtkCellArray* newConnectivity, - vtkIdTypeArray* newLocations, - vtkIdType* pointsCell, - int& alreadyCopied, - int start, - int end) +void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray * newTypes, + const std::vector& idCellsNewToOld, + const std::vector& idNodesOldToNew, + vtkCellArray* newConnectivity, + vtkIdTypeArray* newLocations, + std::vector& pointsCell) { - //MESSAGE("copyBloc " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start); - for (int j = start; j < end; j++) + for ( size_t iNew = 0; iNew < idCellsNewToOld.size(); iNew++ ) + { + int iOld = idCellsNewToOld[ iNew ]; + newTypes->SetValue( iNew, this->Types->GetValue( iOld )); + + vtkIdType oldLoc = ((vtkIdTypeArray *)(this->Connectivity->GetOffsetsArray()))->GetValue( iOld ); + vtkIdType nbpts; + vtkIdType const *oldPtsCell(nullptr); + this->Connectivity->GetCell( oldLoc+iOld, nbpts, oldPtsCell ); + if ((vtkIdType) pointsCell.size() < nbpts ) + pointsCell.resize( nbpts ); + for ( int l = 0; l < nbpts; l++ ) { - newTypes->SetValue(alreadyCopied, this->Types->GetValue(j)); - idCellsOldToNew[j] = alreadyCopied; // old vtkId --> new vtkId - vtkIdType oldLoc = this->Locations->GetValue(j); - vtkIdType nbpts; - vtkIdType *oldPtsCell = 0; - this->Connectivity->GetCell(oldLoc, nbpts, oldPtsCell); - assert(nbpts < NBMAXNODESINCELL); - //MESSAGE(j << " " << alreadyCopied << " " << (int)this->Types->GetValue(j) << " " << oldLoc << " " << nbpts ); - for (int l = 0; l < nbpts; l++) - { - int oldval = oldPtsCell[l]; - pointsCell[l] = idNodesOldToNew[oldval]; - //MESSAGE(" " << oldval << " " << pointsCell[l]); - } - /*int newcnt = */newConnectivity->InsertNextCell(nbpts, pointsCell); - int newLoc = newConnectivity->GetInsertLocation(nbpts); - //MESSAGE(newcnt << " " << newLoc); - newLocations->SetValue(alreadyCopied, newLoc); - alreadyCopied++; + int oldval = oldPtsCell[l]; + pointsCell[l] = idNodesOldToNew[oldval]; } + /*int newcnt = */newConnectivity->InsertNextCell( nbpts, pointsCell.data() ); + int newLoc = newConnectivity->GetInsertLocation( nbpts ); + newLocations->SetValue( iNew, newLoc ); + } } int SMDS_UnstructuredGrid::CellIdToDownId(int vtkCellId) { - if((vtkCellId < 0) || (vtkCellId >= _cellIdToDownId.size())) - { - //MESSAGE("SMDS_UnstructuredGrid::CellIdToDownId structure not up to date: vtkCellId=" - // << vtkCellId << " max="<< _cellIdToDownId.size()); - return -1; - } + if ((vtkCellId < 0) || (vtkCellId >= (int)_cellIdToDownId.size())) + { + return -1; + } return _cellIdToDownId[vtkCellId]; } @@ -371,12 +397,12 @@ void SMDS_UnstructuredGrid::setCellIdToDownId(int vtkCellId, int downId) void SMDS_UnstructuredGrid::CleanDownwardConnectivity() { - for (int i = 0; i < _downArray.size(); i++) - { - if (_downArray[i]) - delete _downArray[i]; - _downArray[i] = 0; - } + for (size_t i = 0; i < _downArray.size(); i++) + { + if (_downArray[i]) + delete _downArray[i]; + _downArray[i] = 0; + } _cellIdToDownId.clear(); } @@ -384,7 +410,7 @@ void SMDS_UnstructuredGrid::CleanDownwardConnectivity() * Downward connectivity is no more valid if vtkUnstructuredGrid is modified. * */ -void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) +void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool /*withEdges*/) { MESSAGE("SMDS_UnstructuredGrid::BuildDownwardConnectivity");CHRONO(2); // TODO calcul partiel sans edges @@ -456,6 +482,7 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) GuessSize[VTK_QUADRATIC_HEXAHEDRON] = nbQuadHexa; GuessSize[VTK_TRIQUADRATIC_HEXAHEDRON] = nbQuadHexa; GuessSize[VTK_HEXAGONAL_PRISM] = nbHexPrism; + (void)GuessSize; // unused in Release mode _downArray[VTK_LINE] ->allocate(nbLineGuess); _downArray[VTK_QUADRATIC_EDGE] ->allocate(nbQuadEdgeGuess); @@ -625,7 +652,7 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) int connEdgeId = _downArray[vtkEdgeType]->addCell(vtkEdgeId); SMDS_Down1D* downEdge = static_cast (_downArray[vtkEdgeType]); downEdge->setNodes(connEdgeId, vtkEdgeId); - vector vtkIds; + std::vector vtkIds; int nbVtkCells = downEdge->computeVtkCells(connEdgeId, vtkIds); int downFaces[1000]; unsigned char downTypes[1000]; @@ -674,7 +701,7 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) // --- check if the edge is already registered by exploration of the faces //CHRONO(41); - vector vtkIds; + std::vector vtkIds; unsigned char vtkEdgeType = edgesWithNodes.elems[iedge].vtkType; int *pts = &edgesWithNodes.elems[iedge].nodeIds[0]; SMDS_Down1D* downEdge = static_cast (_downArray[vtkEdgeType]); @@ -728,7 +755,7 @@ void SMDS_UnstructuredGrid::BuildDownwardConnectivity(bool withEdges) CHRONOSTOP(23);CHRONO(24); - // compact downward connectivity structure: adjust downward arrays size, replace vector> by a single vector + // compact downward connectivity structure: adjust downward arrays size, replace std::vector> by a single std::vector // 3D first then 2D and last 1D to release memory before edge upCells reorganization, (temporary memory use) for (int vtkType = VTK_QUADRATIC_PYRAMID; vtkType >= 0; vtkType--) @@ -953,8 +980,10 @@ void SMDS_UnstructuredGrid::GetNodeIds(std::set& nodeSet, int downId, unsig void SMDS_UnstructuredGrid::ModifyCellNodes(int vtkVolId, std::map localClonedNodeIds) { vtkIdType npts = 0; - vtkIdType *pts; // will refer to the point id's of the face - this->GetCellPoints(vtkVolId, npts, pts); + vtkIdType const *tmp(nullptr); // will refer to the point id's of the face + vtkIdType *pts; // will refer to the point id's of the face + this->GetCellPoints(vtkVolId, npts, tmp); + pts = const_cast< vtkIdType*>( tmp ); for (int i = 0; i < npts; i++) { if (localClonedNodeIds.count(pts[i])) @@ -991,17 +1020,34 @@ void SMDS_UnstructuredGrid::BuildLinks() { // Remove the old links if they are already built if (this->Links) - { + { this->Links->UnRegister(this); - } + } - this->Links = SMDS_CellLinks::New(); - this->Links->Allocate(this->GetNumberOfPoints()); + SMDS_CellLinks* links; + this->Links = links = SMDS_CellLinks::New(); + (static_cast< vtkCellLinks *>(this->Links.GetPointer()))->Allocate(this->GetNumberOfPoints()); this->Links->Register(this); - this->Links->BuildLinks(this, this->Connectivity); + links->BuildLinks(this, this->Connectivity,this->GetCellTypesArray() ); this->Links->Delete(); } +void SMDS_UnstructuredGrid::DeleteLinks() +{ + // Remove the old links if they are already built + if (this->Links) + { + this->Links->UnRegister(this); + this->Links = NULL; + } +} +SMDS_CellLinks* SMDS_UnstructuredGrid::GetLinks() +{ + if ( !this->Links ) + BuildLinks(); + return static_cast< SMDS_CellLinks* >( this->Links.GetPointer() ); +} + /*! Create a volume (prism or hexahedron) by duplication of a face. * Designed for use in creation of flat elements separating volume domains. * A face separating two domains is shared by two volume cells. @@ -1016,37 +1062,34 @@ void SMDS_UnstructuredGrid::BuildLinks() * @param nodeDomains: map(original id --> map(domain --> duplicated node id)) * @return ok if success. */ -SMDS_MeshCell* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId, - int domain1, - int domain2, - std::set& originalNodes, - std::map >& nodeDomains, - std::map >& nodeQuadDomains) +SMDS_MeshCell* +SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId, + int domain1, + int domain2, + std::set& originalNodes, + std::map >& nodeDomains, + std::map >& nodeQuadDomains) { //MESSAGE("extrudeVolumeFromFace " << vtkVolId); - vector orderedOriginals; - orderedOriginals.clear(); - set::const_iterator it = originalNodes.begin(); - for (; it != originalNodes.end(); ++it) - orderedOriginals.push_back(*it); + std::vector orderedOriginals( originalNodes.begin(), originalNodes.end() ); int dim = 0; int nbNodes = this->getOrderedNodesOfFace(vtkVolId, dim, orderedOriginals); - vector orderedNodes; + std::vector orderedNodes; bool isQuadratic = false; switch (orderedOriginals.size()) { - case 3: - if (dim == 2) - isQuadratic = true; - break; - case 6: - case 8: + case 3: + if (dim == 2) isQuadratic = true; - break; - default: - isQuadratic = false; + break; + case 6: + case 8: + isQuadratic = true; + break; + default: + isQuadratic = false; break; } @@ -1081,7 +1124,7 @@ SMDS_MeshCell* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId, { double *coords = this->GetPoint(oldId); SMDS_MeshNode *newNode = _mesh->AddNode(coords[0], coords[1], coords[2]); - newId = newNode->getVtkId(); + newId = newNode->GetVtkID(); if (! nodeQuadDomains.count(oldId)) { std::map emptyMap; @@ -1165,4 +1208,3 @@ double SMDS_UnstructuredGrid::GetBallDiameter( vtkIdType vtkID ) const return vtkDoubleArray::SafeDownCast( vtkDataSet::CellData->GetScalars() )->GetValue( vtkID ); return 0; } -