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

#4683 clang-format on all files in ApplicationCode

Browse Source
This commit is contained in:
Magne Sjaastad
2019-09-06 10:40:57 +02:00
parent 3a317504bb
commit fe9e567825
2092 changed files with 117952 additions and 111846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
ApplicationCode/ModelVisualization/Riv3dWellLogDrawSurfaceGenerator.cpp
View File

@@ -26,11 +26,11 @@
#include "cafDisplayCoordTransform.h"
#include "cvfObject.h"
#include "cvfPrimitiveSetIndexedUInt.h"
#include "cvfArrowGenerator.h"
#include "cvfBoundingBox.h"
#include "cvfGeometryBuilderTriangles.h"
#include "cvfArrowGenerator.h"
#include "cvfObject.h"
#include "cvfPrimitiveSetIndexedUInt.h"
#include <algorithm>
#include <map>
@@ -38,94 +38,102 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Riv3dWellLogDrawSurfaceGenerator::Riv3dWellLogDrawSurfaceGenerator(RimWellPath* wellPath)
: m_wellPath(wellPath)
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)
bool Riv3dWellLogDrawSurfaceGenerator::createDrawSurface( const caf::DisplayCoordTransform* displayCoordTransform,
const cvf::BoundingBox& wellPathClipBoundingBox,
double planeAngle,
double planeOffsetFromWellPathCenter,
double planeWidth,
double samplingIntervalSize )
{
CVF_ASSERT(samplingIntervalSize > 0);
CVF_ASSERT( samplingIntervalSize > 0 );
clearGeometry();
if (!wellPathGeometry() || wellPathGeometry()->m_measuredDepths.empty())
if ( !wellPathGeometry() || wellPathGeometry()->m_measuredDepths.empty() )
{
return false;
}
if (!wellPathClipBoundingBox.isValid())
if ( !wellPathClipBoundingBox.isValid() )
{
return false;
}
RimWellPathCollection* wellPathCollection = nullptr;
m_wellPath->firstAncestorOrThisOfTypeAsserted(wellPathCollection);
m_wellPath->firstAncestorOrThisOfTypeAsserted( wellPathCollection );
std::vector<cvf::Vec3d> wellPathDisplayCoords;
{
std::vector<cvf::Vec3d> domainCoords = wellPathGeometry()->m_wellPathPoints;
if (domainCoords.size() < (size_t)2)
if ( domainCoords.size() < (size_t)2 )
{
// Need at least two well path points to create a valid path.
return false;
}
wellPathDisplayCoords = displayCoordTransform->transformToDisplayCoords(domainCoords);
wellPathDisplayCoords = displayCoordTransform->transformToDisplayCoords( domainCoords );
}
std::vector<cvf::Vec3d> wellPathSegmentNormals =
RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathDisplayCoords, planeAngle);
RigWellPathGeometryTools::calculateLineSegmentNormals( wellPathDisplayCoords, planeAngle );
size_t indexToFirstVisibleSegment = 0u;
if (wellPathCollection->wellPathClip)
if ( wellPathCollection->wellPathClip )
{
double clipZDistance = wellPathCollection->wellPathClipZDistance;
cvf::Vec3d clipLocation = wellPathClipBoundingBox.max() + clipZDistance * cvf::Vec3d(0, 0, 1);
clipLocation = displayCoordTransform->transformToDisplayCoord(clipLocation);
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);
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);
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());
wellPathSegmentNormals.erase( wellPathSegmentNormals.begin(),
wellPathSegmentNormals.end() - wellPathDisplayCoords.size() );
if (wellPathDisplayCoords.size() < (size_t)2)
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.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));
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)
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]);
( *vertexArray )[i] = cvf::Vec3f( m_vertices[i] );
}
createBackground(vertexArray.p());
createBorder(vertexArray.p());
createBackground( vertexArray.p() );
createBorder( vertexArray.p() );
return true;
}
@@ -134,8 +142,8 @@ Riv3dWellLogDrawSurfaceGenerator::createDrawSurface(const caf::DisplayCoordTrans
//--------------------------------------------------------------------------------------------------
void Riv3dWellLogDrawSurfaceGenerator::clearGeometry()
{
m_background = nullptr;
m_border = nullptr;
m_background = nullptr;
m_border = nullptr;
m_curveNormalVectors = nullptr;
m_vertices.clear();
}
@@ -175,133 +183,135 @@ const std::vector<cvf::Vec3d>& Riv3dWellLogDrawSurfaceGenerator::vertices() cons
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Riv3dWellLogDrawSurfaceGenerator::createCurveNormalVectors(const caf::DisplayCoordTransform* displayCoordTransform,
size_t clipStartIndex,
double planeOffsetFromWellPathCenter,
double planeWidth,
double samplingIntervalSize,
const std::vector<cvf::Vec3d>& segmentNormals)
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()->m_measuredDepths.at(clipStartIndex);
double lastMd = wellPathGeometry()->m_measuredDepths.back();
double firstMd = wellPathGeometry()->m_measuredDepths.at( clipStartIndex );
double lastMd = wellPathGeometry()->m_measuredDepths.back();
double md = lastMd;
while (md >= firstMd)
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());
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());
arrowVertices.reserve( interpolatedWellPathPoints.size() );
arrowVectors.reserve( interpolatedWellPathPoints.size() );
double shaftRelativeRadius = 0.0125f;
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++)
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));
arrowVertices.push_back( cvf::Vec3f( interpolatedWellPathPoints[i] +
interpolatedWellPathNormals[i] * planeOffsetFromWellPathCenter ) );
arrowVectors.push_back(cvf::Vec3f(interpolatedWellPathNormals[i] * planeWidth * totalArrowScaling));
arrowVectors.push_back( cvf::Vec3f( interpolatedWellPathNormals[i] * planeWidth * totalArrowScaling ) );
}
if (arrowVertices.empty() || arrowVectors.empty())
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);
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);
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());
m_curveNormalVectors->setGlyph( arrowBuilder.trianglesUShort().p(), arrowBuilder.vertices().p() );
m_curveNormalVectors->setVectors( vertexArray.p(), vectorArray.p() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Riv3dWellLogDrawSurfaceGenerator::createBackground(cvf::Vec3fArray* vertexArray)
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.reserve( vertexArray->size() );
for ( size_t i = 0; i < vertexArray->size(); ++i )
{
backgroundIndices.push_back((cvf::uint) (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());
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);
m_background->addPrimitiveSet( indexedUInt.p() );
m_background->setVertexArray( vertexArray );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Riv3dWellLogDrawSurfaceGenerator::createBorder(cvf::Vec3fArray* vertexArray)
void Riv3dWellLogDrawSurfaceGenerator::createBorder( cvf::Vec3fArray* vertexArray )
{
std::vector<cvf::uint> borderIndices;
borderIndices.reserve(m_vertices.size());
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)
for ( int i = 0; i <= secondLastEvenVertex; i += 2 )
{
borderIndices.push_back((cvf::uint) i);
borderIndices.push_back((cvf::uint) 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));
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;
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)
for ( int i = lastOddVertex; i >= secondOddVertex; i -= 2 )
{
borderIndices.push_back((cvf::uint) i);
borderIndices.push_back((cvf::uint) 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);
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());
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);
m_border->addPrimitiveSet( indexedUInt.p() );
m_border->setVertexArray( vertexArray );
}
//--------------------------------------------------------------------------------------------------