OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#6314 PTL format from generated surface

Browse Source 
Co-authored-by: Ruben Manuel Thoms <ruben.thoms@ceetronsolutions.com>
This commit is contained in:
Magne Sjaastad 2020-08-24 13:59:22 +02:00
parent 14e0a9c2da
commit 0bd328f4df
2 changed files with 126 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
ApplicationCode/ProjectDataModel/Surfaces/RimGridCaseSurface.cpp
View File

@ -158,8 +158,6 @@ void RimGridCaseSurface::extractDataFromGrid()
{ {
clearCachedNativeData(); clearCachedNativeData();
RiaDefines::GridCaseAxis sliceDirection = RiaDefines::GridCaseAxis::AXIS_K;
if ( m_case ) if ( m_case )
{ {
RimEclipseCase* eclCase = dynamic_cast<RimEclipseCase*>( m_case() ); RimEclipseCase* eclCase = dynamic_cast<RimEclipseCase*>( m_case() );
@ -167,66 +165,80 @@ void RimGridCaseSurface::extractDataFromGrid()
{ {
const RigMainGrid* grid = eclCase->mainGrid(); const RigMainGrid* grid = eclCase->mainGrid();
size_t minI = 0; size_t minI = 0;
size_t minJ = 0; size_t minJ = 0;
size_t minK = 0; size_t minK = 0;
size_t maxI = grid->cellCountI(); size_t maxI = grid->cellCountI();
size_t maxJ = grid->cellCountJ(); size_t maxJ = grid->cellCountJ();
size_t maxK = grid->cellCountK(); size_t maxK = grid->cellCountK();
size_t row = 0;
size_t maxRow = 0;
size_t column = 0;
size_t maxColumn = 0;
size_t zeroBasedLayerIndex = static_cast<size_t>( m_oneBasedSliceIndex - 1 ); size_t zeroBasedLayerIndex = static_cast<size_t>( m_oneBasedSliceIndex ) - 1;
cvf::StructGridInterface::FaceType faceType = cvf::StructGridInterface::NO_FACE; cvf::StructGridInterface::FaceType faceType = cvf::StructGridInterface::NO_FACE;
{ {
auto sliceDirection = RiaDefines::GridCaseAxis::AXIS_K;
if ( sliceDirection == RiaDefines::GridCaseAxis::AXIS_K ) if ( sliceDirection == RiaDefines::GridCaseAxis::AXIS_K )
{ {
faceType = cvf::StructGridInterface::NEG_K; faceType = cvf::StructGridInterface::NEG_K;
minK = zeroBasedLayerIndex; minK = zeroBasedLayerIndex;
maxK = zeroBasedLayerIndex + 1; maxK = zeroBasedLayerIndex;
maxRow = maxJ;
maxColumn = maxI;
} }
else if ( sliceDirection == RiaDefines::GridCaseAxis::AXIS_J ) else if ( sliceDirection == RiaDefines::GridCaseAxis::AXIS_J )
{ {
faceType = cvf::StructGridInterface::NEG_J; faceType = cvf::StructGridInterface::NEG_J;
minJ = zeroBasedLayerIndex; minJ = zeroBasedLayerIndex;
maxJ = zeroBasedLayerIndex + 1; maxJ = zeroBasedLayerIndex;
maxRow = maxK;
maxColumn = maxI;
} }
else if ( sliceDirection == RiaDefines::GridCaseAxis::AXIS_I ) else if ( sliceDirection == RiaDefines::GridCaseAxis::AXIS_I )
{ {
faceType = cvf::StructGridInterface::NEG_I; faceType = cvf::StructGridInterface::NEG_I;
minI = zeroBasedLayerIndex; minI = zeroBasedLayerIndex;
maxI = zeroBasedLayerIndex + 1; maxI = zeroBasedLayerIndex;
maxRow = maxK;
maxColumn = maxJ;
} }
} }
std::vector<unsigned> tringleIndices; std::vector<unsigned> triangleIndices;
std::vector<cvf::Vec3d> vertices; std::vector<cvf::Vec3d> vertices;
std::vector<std::pair<unsigned, unsigned>> structGridVertexIndices; std::vector<std::pair<unsigned, unsigned>> structGridVertexIndices;
for ( size_t i = minI; i < maxI; i++ ) for ( size_t i = minI; i <= maxI; i++ )
{ {
for ( size_t j = minJ; j < maxJ; j++ ) for ( size_t j = minJ; j <= maxJ; j++ )
{ {
for ( size_t k = minK; k < maxK; k++ ) for ( size_t k = minK; k <= maxK; k++ )
{ {
std::pair<unsigned, unsigned> quadIJIndices;
switch ( faceType ) switch ( faceType )
{ {
case cvf::StructGridInterface::NEG_I: case cvf::StructGridInterface::NEG_I:
quadIJIndices = std::make_pair( j, k ); row = k;
column = j;
break; break;
case cvf::StructGridInterface::NEG_J: case cvf::StructGridInterface::NEG_J:
quadIJIndices = std::make_pair( i, k ); row = k;
column = i;
break; break;
case cvf::StructGridInterface::NEG_K: case cvf::StructGridInterface::NEG_K:
quadIJIndices = std::make_pair( i, j ); row = j;
column = i;
break; break;
} }
size_t cellIndex = grid->cellIndexFromIJK( i, j, k ); size_t cellIndex = 0;
size_t cellFaceIndex = 0;
if ( grid->cell( cellIndex ).isInvalid() ) continue; if ( !findValidCellIndex( grid, faceType, cellIndex, row, column, zeroBasedLayerIndex, cellFaceIndex ) )
return;
cvf::Vec3d cornerVerts[8]; cvf::Vec3d cornerVerts[8];
grid->cellCornerVertices( cellIndex, cornerVerts ); grid->cellCornerVertices( cellIndex, cornerVerts );
@ -234,37 +246,98 @@ void RimGridCaseSurface::extractDataFromGrid()
cvf::ubyte faceConn[4]; cvf::ubyte faceConn[4];
grid->cellFaceVertexIndices( faceType, faceConn ); grid->cellFaceVertexIndices( faceType, faceConn );
cvf::uint triangleIndex = static_cast<cvf::uint>( vertices.size() ); structGridVertexIndices.push_back(
std::make_pair( static_cast<cvf::uint>( column + 1 ), static_cast<cvf::uint>( row + 1 ) ) );
for ( int n = 0; n < 4; n++ ) vertices.push_back( cornerVerts[faceConn[cellFaceIndex]] );
if ( row < maxRow && column < maxColumn )
{ {
auto localIndexPair = getStructGridIndex( faceType, faceConn[n] ); cvf::uint triangleIndexLeft = static_cast<cvf::uint>( column * ( maxRow + 1 ) + row );
cvf::uint triangleIndexRight = static_cast<cvf::uint>( ( column + 1 ) * ( maxRow + 1 ) + row );
structGridVertexIndices.push_back( triangleIndices.push_back( triangleIndexLeft );
std::make_pair( quadIJIndices.first + localIndexPair.first, triangleIndices.push_back( triangleIndexLeft + 1 );
quadIJIndices.second + localIndexPair.second ) ); triangleIndices.push_back( triangleIndexRight + 1 );
vertices.push_back( cornerVerts[faceConn[n]] ); triangleIndices.push_back( triangleIndexLeft );
triangleIndices.push_back( triangleIndexRight + 1 );
triangleIndices.push_back( triangleIndexRight );
} }
tringleIndices.push_back( triangleIndex + 0 );
tringleIndices.push_back( triangleIndex + 1 );
tringleIndices.push_back( triangleIndex + 2 );
tringleIndices.push_back( triangleIndex + 0 );
tringleIndices.push_back( triangleIndex + 2 );
tringleIndices.push_back( triangleIndex + 3 );
} }
} }
} }
m_vertices = vertices; m_vertices = vertices;
m_tringleIndices = tringleIndices; m_tringleIndices = triangleIndices;
m_structGridIndices = structGridVertexIndices; m_structGridIndices = structGridVertexIndices;
} }
} }
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimGridCaseSurface::findValidCellIndex( const RigMainGrid* grid,
const cvf::StructGridInterface::FaceType faceType,
size_t& cellIndex,
const size_t row,
const size_t column,
const size_t layer,
size_t& cellFaceIndex )
{
auto getCellFromRowColumnLayer = [grid, faceType]( size_t row, size_t column, size_t layer ) -> size_t {
if ( faceType == cvf::StructGridInterface::NEG_I ) return grid->cellIndexFromIJK( layer, column, row );
if ( faceType == cvf::StructGridInterface::NEG_J ) return grid->cellIndexFromIJK( column, layer, row );
return grid->cellIndexFromIJK( column, row, layer );
};
auto isCellValid = [grid, faceType]( size_t row, size_t column, size_t layer ) -> bool {
if ( faceType == cvf::StructGridInterface::NEG_I )
{
return column < grid->cellCountJ() && row < grid->cellCountK() &&
!grid->cell( grid->cellIndexFromIJK( layer, column, row ) ).isInvalid();
}
if ( faceType == cvf::StructGridInterface::NEG_J )
{
return column < grid->cellCountI() && row < grid->cellCountK() &&
!grid->cell( grid->cellIndexFromIJK( column, layer, row ) ).isInvalid();
}
return column < grid->cellCountI() && row < grid->cellCountJ() &&
!grid->cell( grid->cellIndexFromIJK( column, row, layer ) ).isInvalid();
};
if ( isCellValid( row, column, layer ) )
{
cellIndex = getCellFromRowColumnLayer( row, column, layer );
cellFaceIndex = 0;
return true;
}
if ( isCellValid( row - 1, column, layer ) )
{
cellIndex = getCellFromRowColumnLayer( row - 1, column, layer );
cellFaceIndex = 1;
return true;
}
if ( isCellValid( row, column - 1, layer ) )
{
cellIndex = getCellFromRowColumnLayer( row, column - 1, layer );
cellFaceIndex = 3;
return true;
}
if ( isCellValid( row - 1, column - 1, layer ) )
{
cellIndex = getCellFromRowColumnLayer( row - 1, column - 1, layer );
cellFaceIndex = 2;
return true;
}
return false;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -275,35 +348,6 @@ void RimGridCaseSurface::clearCachedNativeData()
m_structGridIndices.clear(); m_structGridIndices.clear();
} }
//--------------------------------------------------------------------------------------------------
/// Return local column and row number for structured grid based on a given cell face.
/// Argument faceType may be superfluous depending on winding and particular NEG_I face may
/// need particular handling, see StructGridInterface::cellFaceVertexIndices().
//
// 7---------6
// /| /| |k
// / | / | | /j
// 4---------5 | |/
// | 3------|--2 *---i
// | / | /
// |/ |/
// 0---------1
//--------------------------------------------------------------------------------------------------
std::pair<cvf::uint, cvf::uint> RimGridCaseSurface::getStructGridIndex( cvf::StructGridInterface::FaceType faceType,
cvf::ubyte localVertexIndex )
{
std::pair<unsigned, unsigned> localIndexPair;
CVF_TIGHT_ASSERT( localVertexIndex <= 3 );
if ( localVertexIndex == 0 ) localIndexPair = std::make_pair( 0, 0 );
if ( localVertexIndex == 1 ) localIndexPair = std::make_pair( 1, 0 );
if ( localVertexIndex == 2 ) localIndexPair = std::make_pair( 1, 1 );
if ( localVertexIndex == 3 ) localIndexPair = std::make_pair( 0, 1 );
return localIndexPair;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// Returns false for fatal failure /// Returns false for fatal failure
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

9
ApplicationCode/ProjectDataModel/Surfaces/RimGridCaseSurface.h
View File

@ -26,6 +26,7 @@
#include "cvfStructGrid.h" #include "cvfStructGrid.h"
class RigMainGrid;
class RimCase; class RimCase;
class RimGridCaseSurface : public RimSurface class RimGridCaseSurface : public RimSurface
@ -63,7 +64,13 @@ private:
void extractDataFromGrid(); void extractDataFromGrid();
std::pair<uint, uint> getStructGridIndex( cvf::StructGridInterface::FaceType cellface, cvf::ubyte localVertexIndex ); bool findValidCellIndex( const RigMainGrid* grid,
const cvf::StructGridInterface::FaceType faceType,
size_t& cellIndex,
const size_t row,
const size_t column,
const size_t layer,
size_t& cellFaceIndex );
private: private:
caf::PdmPtrField<RimCase*> m_case; caf::PdmPtrField<RimCase*> m_case;