mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Rename ApplicationCode to ApplicationLibCode
This commit is contained in:
Gaute Lindkvist
@@ -0,0 +1,323 @@
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Copyright (C) 2018- Equinor ASA
|
||||
//
|
||||
// ResInsight is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
|
||||
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
// FITNESS FOR A PARTICULAR PURPOSE.
|
||||
//
|
||||
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
|
||||
// for more details.
|
||||
//
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "Riv3dWellLogDrawSurfaceGenerator.h"
|
||||
|
||||
#include "RimWellPath.h"
|
||||
#include "RimWellPathCollection.h"
|
||||
|
||||
#include "RigWellPath.h"
|
||||
#include "RigWellPathGeometryTools.h"
|
||||
|
||||
#include "cafDisplayCoordTransform.h"
|
||||
|
||||
#include "cvfArrowGenerator.h"
|
||||
#include "cvfBoundingBox.h"
|
||||
#include "cvfGeometryBuilderTriangles.h"
|
||||
#include "cvfObject.h"
|
||||
#include "cvfPrimitiveSetIndexedUInt.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
Riv3dWellLogDrawSurfaceGenerator::Riv3dWellLogDrawSurfaceGenerator( RimWellPath* wellPath )
|
||||
: m_wellPath( wellPath )
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool Riv3dWellLogDrawSurfaceGenerator::createDrawSurface( const caf::DisplayCoordTransform* displayCoordTransform,
|
||||
const cvf::BoundingBox& wellPathClipBoundingBox,
|
||||
double planeAngle,
|
||||
double planeOffsetFromWellPathCenter,
|
||||
double planeWidth,
|
||||
double samplingIntervalSize )
|
||||
{
|
||||
CVF_ASSERT( samplingIntervalSize > 0 );
|
||||
|
||||
clearGeometry();
|
||||
|
||||
if ( !wellPathGeometry() || wellPathGeometry()->measuredDepths().empty() )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( !wellPathClipBoundingBox.isValid() )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
RimWellPathCollection* wellPathCollection = nullptr;
|
||||
m_wellPath->firstAncestorOrThisOfTypeAsserted( wellPathCollection );
|
||||
|
||||
std::vector<cvf::Vec3d> wellPathDisplayCoords;
|
||||
{
|
||||
const std::vector<cvf::Vec3d>& domainCoords = wellPathGeometry()->wellPathPoints();
|
||||
if ( domainCoords.size() < (size_t)2 )
|
||||
{
|
||||
// Need at least two well path points to create a valid path.
|
||||
return false;
|
||||
}
|
||||
|
||||
wellPathDisplayCoords = displayCoordTransform->transformToDisplayCoords( domainCoords );
|
||||
}
|
||||
|
||||
std::vector<cvf::Vec3d> wellPathSegmentNormals =
|
||||
RigWellPathGeometryTools::calculateLineSegmentNormals( wellPathDisplayCoords, planeAngle );
|
||||
|
||||
size_t indexToFirstVisibleSegment = 0u;
|
||||
if ( wellPathCollection->wellPathClip )
|
||||
{
|
||||
double clipZDistance = wellPathCollection->wellPathClipZDistance;
|
||||
cvf::Vec3d clipLocation = wellPathClipBoundingBox.max() + clipZDistance * cvf::Vec3d( 0, 0, 1 );
|
||||
clipLocation = displayCoordTransform->transformToDisplayCoord( clipLocation );
|
||||
double horizontalLengthAlongWellToClipPoint;
|
||||
|
||||
wellPathDisplayCoords = RigWellPath::clipPolylineStartAboveZ( wellPathDisplayCoords,
|
||||
clipLocation.z(),
|
||||
&horizontalLengthAlongWellToClipPoint,
|
||||
&indexToFirstVisibleSegment );
|
||||
}
|
||||
|
||||
// Create curve normal vectors using the unclipped well path points and normals.
|
||||
createCurveNormalVectors( displayCoordTransform,
|
||||
indexToFirstVisibleSegment,
|
||||
planeOffsetFromWellPathCenter,
|
||||
planeWidth,
|
||||
samplingIntervalSize,
|
||||
wellPathSegmentNormals );
|
||||
|
||||
// Note that normals are calculated on the full non-clipped well path. So we need to clip the start here.
|
||||
wellPathSegmentNormals.erase( wellPathSegmentNormals.begin(),
|
||||
wellPathSegmentNormals.end() - wellPathDisplayCoords.size() );
|
||||
|
||||
if ( wellPathDisplayCoords.size() < (size_t)2 )
|
||||
{
|
||||
// Need at least two well path points to create a valid path.
|
||||
return false;
|
||||
}
|
||||
|
||||
m_vertices.reserve( wellPathDisplayCoords.size() * 2 );
|
||||
for ( size_t i = 0; i < wellPathDisplayCoords.size(); i++ )
|
||||
{
|
||||
m_vertices.push_back( wellPathDisplayCoords[i] +
|
||||
wellPathSegmentNormals[i] * ( planeOffsetFromWellPathCenter - 0.025 * planeWidth ) );
|
||||
m_vertices.push_back( wellPathDisplayCoords[i] +
|
||||
wellPathSegmentNormals[i] * ( planeOffsetFromWellPathCenter + 1.025 * planeWidth ) );
|
||||
}
|
||||
|
||||
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray( m_vertices.size() );
|
||||
for ( size_t i = 0; i < m_vertices.size(); ++i )
|
||||
{
|
||||
( *vertexArray )[i] = cvf::Vec3f( m_vertices[i] );
|
||||
}
|
||||
createBackground( vertexArray.p() );
|
||||
createBorder( vertexArray.p() );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void Riv3dWellLogDrawSurfaceGenerator::clearGeometry()
|
||||
{
|
||||
m_background = nullptr;
|
||||
m_border = nullptr;
|
||||
m_curveNormalVectors = nullptr;
|
||||
m_vertices.clear();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::DrawableGeo> Riv3dWellLogDrawSurfaceGenerator::background() const
|
||||
{
|
||||
return m_background;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::DrawableGeo> Riv3dWellLogDrawSurfaceGenerator::border() const
|
||||
{
|
||||
return m_border;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::DrawableVectors> Riv3dWellLogDrawSurfaceGenerator::curveNormalVectors() const
|
||||
{
|
||||
return m_curveNormalVectors;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const std::vector<cvf::Vec3d>& Riv3dWellLogDrawSurfaceGenerator::vertices() const
|
||||
{
|
||||
return m_vertices;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void Riv3dWellLogDrawSurfaceGenerator::createCurveNormalVectors( const caf::DisplayCoordTransform* displayCoordTransform,
|
||||
size_t clipStartIndex,
|
||||
double planeOffsetFromWellPathCenter,
|
||||
double planeWidth,
|
||||
double samplingIntervalSize,
|
||||
const std::vector<cvf::Vec3d>& segmentNormals )
|
||||
{
|
||||
std::vector<cvf::Vec3d> interpolatedWellPathPoints;
|
||||
std::vector<cvf::Vec3d> interpolatedWellPathNormals;
|
||||
|
||||
double firstMd = wellPathGeometry()->measuredDepths().at( clipStartIndex );
|
||||
double lastMd = wellPathGeometry()->measuredDepths().back();
|
||||
|
||||
double md = lastMd;
|
||||
while ( md >= firstMd )
|
||||
{
|
||||
cvf::Vec3d point = wellPathGeometry()->interpolatedPointAlongWellPath( md );
|
||||
point = displayCoordTransform->transformToDisplayCoord( point );
|
||||
cvf::Vec3d curveNormal = wellPathGeometry()->interpolatedVectorValuesAlongWellPath( segmentNormals, md );
|
||||
interpolatedWellPathPoints.push_back( point );
|
||||
interpolatedWellPathNormals.push_back( curveNormal.getNormalized() );
|
||||
md -= samplingIntervalSize;
|
||||
}
|
||||
|
||||
std::vector<cvf::Vec3f> arrowVertices;
|
||||
std::vector<cvf::Vec3f> arrowVectors;
|
||||
arrowVertices.reserve( interpolatedWellPathPoints.size() );
|
||||
arrowVectors.reserve( interpolatedWellPathPoints.size() );
|
||||
|
||||
double shaftRelativeRadius = 0.0125f;
|
||||
double arrowHeadRelativeRadius = shaftRelativeRadius * 3;
|
||||
double arrowHeadRelativeLength = arrowHeadRelativeRadius * 3;
|
||||
double totalArrowScaling = 1.0 / ( 1.0 - arrowHeadRelativeLength );
|
||||
// Normal lines. Start from one to avoid drawing at surface edge.
|
||||
for ( size_t i = 1; i < interpolatedWellPathNormals.size(); i++ )
|
||||
{
|
||||
arrowVertices.push_back( cvf::Vec3f( interpolatedWellPathPoints[i] +
|
||||
interpolatedWellPathNormals[i] * planeOffsetFromWellPathCenter ) );
|
||||
|
||||
arrowVectors.push_back( cvf::Vec3f( interpolatedWellPathNormals[i] * planeWidth * totalArrowScaling ) );
|
||||
}
|
||||
|
||||
if ( arrowVertices.empty() || arrowVectors.empty() )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
m_curveNormalVectors = new cvf::DrawableVectors();
|
||||
|
||||
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray( arrowVertices );
|
||||
cvf::ref<cvf::Vec3fArray> vectorArray = new cvf::Vec3fArray( arrowVectors );
|
||||
|
||||
// Create the arrow glyph for the vector drawer
|
||||
cvf::GeometryBuilderTriangles arrowBuilder;
|
||||
cvf::ArrowGenerator gen;
|
||||
gen.setShaftRelativeRadius( shaftRelativeRadius );
|
||||
gen.setHeadRelativeRadius( arrowHeadRelativeRadius );
|
||||
gen.setHeadRelativeLength( arrowHeadRelativeLength );
|
||||
gen.setNumSlices( 4 );
|
||||
gen.generate( &arrowBuilder );
|
||||
|
||||
m_curveNormalVectors->setGlyph( arrowBuilder.trianglesUShort().p(), arrowBuilder.vertices().p() );
|
||||
m_curveNormalVectors->setVectors( vertexArray.p(), vectorArray.p() );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void Riv3dWellLogDrawSurfaceGenerator::createBackground( cvf::Vec3fArray* vertexArray )
|
||||
{
|
||||
std::vector<cvf::uint> backgroundIndices;
|
||||
backgroundIndices.reserve( vertexArray->size() );
|
||||
for ( size_t i = 0; i < vertexArray->size(); ++i )
|
||||
{
|
||||
backgroundIndices.push_back( ( cvf::uint )( i ) );
|
||||
}
|
||||
|
||||
// Background specific
|
||||
cvf::ref<cvf::PrimitiveSetIndexedUInt> indexedUInt =
|
||||
new cvf::PrimitiveSetIndexedUInt( cvf::PrimitiveType::PT_TRIANGLE_STRIP );
|
||||
cvf::ref<cvf::UIntArray> indexArray = new cvf::UIntArray( backgroundIndices );
|
||||
indexedUInt->setIndices( indexArray.p() );
|
||||
|
||||
m_background = new cvf::DrawableGeo();
|
||||
m_background->addPrimitiveSet( indexedUInt.p() );
|
||||
m_background->setVertexArray( vertexArray );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void Riv3dWellLogDrawSurfaceGenerator::createBorder( cvf::Vec3fArray* vertexArray )
|
||||
{
|
||||
std::vector<cvf::uint> borderIndices;
|
||||
borderIndices.reserve( m_vertices.size() );
|
||||
|
||||
int secondLastEvenVertex = (int)vertexArray->size() - 4;
|
||||
|
||||
// Border close to the well. All even indices.
|
||||
for ( int i = 0; i <= secondLastEvenVertex; i += 2 )
|
||||
{
|
||||
borderIndices.push_back( (cvf::uint)i );
|
||||
borderIndices.push_back( (cvf::uint)i + 2 );
|
||||
}
|
||||
|
||||
// Connect to border away from well
|
||||
borderIndices.push_back( ( cvf::uint )( vertexArray->size() - 2 ) );
|
||||
borderIndices.push_back( ( cvf::uint )( vertexArray->size() - 1 ) );
|
||||
|
||||
int secondOddVertex = 3;
|
||||
int lastOddVertex = (int)vertexArray->size() - 1;
|
||||
|
||||
// Border away from from well are odd indices in reverse order to create a closed surface.
|
||||
for ( int i = lastOddVertex; i >= secondOddVertex; i -= 2 )
|
||||
{
|
||||
borderIndices.push_back( (cvf::uint)i );
|
||||
borderIndices.push_back( (cvf::uint)i - 2 );
|
||||
}
|
||||
// Close border
|
||||
borderIndices.push_back( 1u );
|
||||
borderIndices.push_back( 0u );
|
||||
|
||||
cvf::ref<cvf::PrimitiveSetIndexedUInt> indexedUInt = new cvf::PrimitiveSetIndexedUInt( cvf::PrimitiveType::PT_LINES );
|
||||
cvf::ref<cvf::UIntArray> indexArray = new cvf::UIntArray( borderIndices );
|
||||
indexedUInt->setIndices( indexArray.p() );
|
||||
|
||||
m_border = new cvf::DrawableGeo();
|
||||
m_border->addPrimitiveSet( indexedUInt.p() );
|
||||
m_border->setVertexArray( vertexArray );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const RigWellPath* Riv3dWellLogDrawSurfaceGenerator::wellPathGeometry() const
|
||||
{
|
||||
return m_wellPath->wellPathGeometry();
|
||||
}
|
||||
Reference in New Issue
Block a user