mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-11 07:56:08 -06:00
289 lines
12 KiB
C++
289 lines
12 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2018- Statoil 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 "Riv3dWellLogPlanePartMgr.h"
|
|
|
|
#include "RiaApplication.h"
|
|
|
|
#include "RiuViewer.h"
|
|
#include "Rim3dView.h"
|
|
#include "Rim3dWellLogCurveCollection.h"
|
|
#include "RimCase.h"
|
|
#include "RimGridView.h"
|
|
#include "RimWellPath.h"
|
|
|
|
#include "Riv3dWellLogCurveGeomertyGenerator.h"
|
|
#include "Riv3dWellLogGridGeomertyGenerator.h"
|
|
|
|
#include "cafDisplayCoordTransform.h"
|
|
#include "cafEffectGenerator.h"
|
|
|
|
#include "cvfBoundingBox.h"
|
|
#include "cvfColor3.h"
|
|
#include "cvfDrawableGeo.h"
|
|
#include "cvfModelBasicList.h"
|
|
#include "cvfOpenGLResourceManager.h"
|
|
#include "cvfPart.h"
|
|
#include "cvfShaderProgram.h"
|
|
|
|
#include <utility>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
Riv3dWellLogPlanePartMgr::Riv3dWellLogPlanePartMgr(RimWellPath* wellPath, RimGridView* gridView)
|
|
: m_wellPath(wellPath)
|
|
, m_gridView(gridView)
|
|
{
|
|
CVF_ASSERT(m_wellPath.notNull());
|
|
m_3dWellLogCurveGeometryGenerator = new Riv3dWellLogCurveGeometryGenerator(m_wellPath.p());
|
|
m_3dWellLogGridGeometryGenerator = new Riv3dWellLogGridGeometryGenerator(m_wellPath.p());
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void Riv3dWellLogPlanePartMgr::appendPlaneToModel(cvf::ModelBasicList* model,
|
|
const caf::DisplayCoordTransform* displayCoordTransform,
|
|
const cvf::BoundingBox& wellPathClipBoundingBox)
|
|
{
|
|
if (m_wellPath.isNull()) return;
|
|
|
|
if (!m_wellPath->rim3dWellLogCurveCollection()) return;
|
|
|
|
if (!m_wellPath->rim3dWellLogCurveCollection()->isShowingPlot()) return;
|
|
|
|
if (m_wellPath->rim3dWellLogCurveCollection()->vectorOf3dWellLogCurves().empty()) return;
|
|
|
|
append3dWellLogCurvesToModel(model, displayCoordTransform, wellPathClipBoundingBox);
|
|
|
|
for (Rim3dWellLogCurve* rim3dWellLogCurve : m_wellPath->rim3dWellLogCurveCollection()->vectorOf3dWellLogCurves())
|
|
{
|
|
appendGridToModel(model, displayCoordTransform, wellPathClipBoundingBox, rim3dWellLogCurve, planeWidth());
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void Riv3dWellLogPlanePartMgr::append3dWellLogCurvesToModel(cvf::ModelBasicList* model,
|
|
const caf::DisplayCoordTransform* displayCoordTransform,
|
|
const cvf::BoundingBox& wellPathClipBoundingBox)
|
|
{
|
|
if (m_wellPath.isNull()) return;
|
|
if (!m_wellPath->rim3dWellLogCurveCollection()) return;
|
|
if (m_wellPath->rim3dWellLogCurveCollection()->vectorOf3dWellLogCurves().empty()) return;
|
|
|
|
const Rim3dWellLogCurveCollection* curveCollection = m_wellPath->rim3dWellLogCurveCollection();
|
|
|
|
size_t colorIndex = 0;
|
|
|
|
for (Rim3dWellLogCurve* rim3dWellLogCurve : m_wellPath->rim3dWellLogCurveCollection()->vectorOf3dWellLogCurves())
|
|
{
|
|
colorIndex++;
|
|
if (!rim3dWellLogCurve->isShowingCurve()) continue;
|
|
|
|
std::vector<double> resultValues;
|
|
std::vector<double> resultMds;
|
|
rim3dWellLogCurve->curveValuesAndMds(&resultValues, &resultMds);
|
|
|
|
cvf::ref<cvf::Drawable> curveDrawable =
|
|
m_3dWellLogCurveGeometryGenerator->createCurveLine(displayCoordTransform,
|
|
wellPathClipBoundingBox,
|
|
resultValues,
|
|
resultMds,
|
|
rim3dWellLogCurve->minCurveValue(),
|
|
rim3dWellLogCurve->maxCurveValue(),
|
|
planeAngle(curveCollection, rim3dWellLogCurve),
|
|
wellPathCenterToPlotStartOffset(curveCollection, rim3dWellLogCurve),
|
|
planeWidth());
|
|
|
|
if (curveDrawable.isNull() || !curveDrawable->boundingBox().isValid())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
caf::MeshEffectGenerator meshEffectGen(rim3dWellLogCurve->color());
|
|
meshEffectGen.setLineWidth(2.0f);
|
|
cvf::ref<cvf::Effect> effect = meshEffectGen.generateCachedEffect();
|
|
|
|
cvf::ref<cvf::Part> part = new cvf::Part;
|
|
part->setDrawable(curveDrawable.p());
|
|
part->setEffect(effect.p());
|
|
|
|
if (part.notNull())
|
|
{
|
|
model->addPart(part.p());
|
|
}
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::ref<cvf::Part> Riv3dWellLogPlanePartMgr::createPart(cvf::Drawable* drawable, cvf::Effect* effect)
|
|
{
|
|
cvf::ref<cvf::Part> part = new cvf::Part;
|
|
|
|
if (drawable && drawable->boundingBox().isValid())
|
|
{
|
|
part->setDrawable(drawable);
|
|
part->setEffect(effect);
|
|
}
|
|
|
|
return part;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double Riv3dWellLogPlanePartMgr::planeAngle(const Rim3dWellLogCurveCollection* collection,
|
|
const Rim3dWellLogCurve* curve)
|
|
{
|
|
switch (curve->drawPlane())
|
|
{
|
|
case Rim3dWellLogCurve::HORIZONTAL_LEFT:
|
|
return cvf::PI_D / 2.0;
|
|
case Rim3dWellLogCurve::HORIZONTAL_RIGHT:
|
|
if (collection->planePositionHorizontal() == Rim3dWellLogCurveCollection::ON_WELLPATH)
|
|
{
|
|
return cvf::PI_D / 2.0; // Always left when on well path
|
|
}
|
|
return -cvf::PI_D / 2.0;
|
|
case Rim3dWellLogCurve::VERTICAL_ABOVE:
|
|
return 0.0;
|
|
case Rim3dWellLogCurve::VERTICAL_BELOW:
|
|
if (collection->planePositionVertical() == Rim3dWellLogCurveCollection::ON_WELLPATH)
|
|
{
|
|
return 0.0; // Always above when on well path.
|
|
}
|
|
return cvf::PI_D;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double Riv3dWellLogPlanePartMgr::wellPathCenterToPlotStartOffset(const Rim3dWellLogCurveCollection* collection, const Rim3dWellLogCurve* curve) const
|
|
{
|
|
bool centered = false;
|
|
if (curve->drawPlane() == Rim3dWellLogCurve::HORIZONTAL_LEFT ||
|
|
curve->drawPlane() == Rim3dWellLogCurve::HORIZONTAL_RIGHT)
|
|
{
|
|
centered = collection->planePositionHorizontal() == Rim3dWellLogCurveCollection::ON_WELLPATH;
|
|
}
|
|
else
|
|
{
|
|
centered = collection->planePositionVertical() == Rim3dWellLogCurveCollection::ON_WELLPATH;
|
|
}
|
|
if (centered)
|
|
{
|
|
return -0.5*planeWidth();
|
|
}
|
|
else
|
|
{
|
|
double cellSize = m_gridView->ownerCase()->characteristicCellSize();
|
|
double wellPathOffset = std::min(m_wellPath->wellPathRadius(cellSize), 0.1 * planeWidth());
|
|
return m_wellPath->wellPathRadius(cellSize) + wellPathOffset;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double Riv3dWellLogPlanePartMgr::planeWidth() const
|
|
{
|
|
if (!m_gridView) return 0;
|
|
|
|
double cellSize = m_gridView->ownerCase()->characteristicCellSize();
|
|
const Rim3dWellLogCurveCollection* curveCollection = m_wellPath->rim3dWellLogCurveCollection();
|
|
return cellSize * curveCollection->planeWidthScaling();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void Riv3dWellLogPlanePartMgr::appendGridToModel(cvf::ModelBasicList* model,
|
|
const caf::DisplayCoordTransform* displayCoordTransform,
|
|
const cvf::BoundingBox& wellPathClipBoundingBox,
|
|
const Rim3dWellLogCurve* rim3dWellLogCurve,
|
|
double gridIntervalSize)
|
|
{
|
|
const Rim3dWellLogCurveCollection* curveCollection = m_wellPath->rim3dWellLogCurveCollection();
|
|
bool showGrid = curveCollection->isShowingGrid();
|
|
bool showBackground = curveCollection->isShowingBackground();
|
|
|
|
cvf::Color3f gridColor(0.4f, 0.4f, 0.4f);
|
|
caf::SurfaceEffectGenerator backgroundEffectGen(cvf::Color4f(1.0, 1.0, 1.0, 1.0), caf::PO_2);
|
|
caf::MeshEffectGenerator gridBorderEffectGen(gridColor);
|
|
caf::VectorEffectGenerator curveNormalsEffectGen;
|
|
backgroundEffectGen.enableLighting(false);
|
|
|
|
bool gridCreated = m_3dWellLogGridGeometryGenerator->createGrid(displayCoordTransform,
|
|
wellPathClipBoundingBox,
|
|
planeAngle(curveCollection, rim3dWellLogCurve),
|
|
wellPathCenterToPlotStartOffset(curveCollection, rim3dWellLogCurve),
|
|
planeWidth(),
|
|
gridIntervalSize);
|
|
if (!gridCreated) return;
|
|
|
|
cvf::ref<cvf::Effect> backgroundEffect = backgroundEffectGen.generateCachedEffect();
|
|
cvf::ref<cvf::Effect> borderEffect = gridBorderEffectGen.generateCachedEffect();
|
|
cvf::ref<cvf::Effect> curveNormalsEffect = curveNormalsEffectGen.generateCachedEffect();
|
|
|
|
cvf::ref<cvf::DrawableGeo> background = m_3dWellLogGridGeometryGenerator->background();
|
|
if (showBackground && background.notNull())
|
|
{
|
|
cvf::ref<cvf::Part> part = createPart(background.p(), backgroundEffect.p());
|
|
if (part.notNull())
|
|
{
|
|
model->addPart(part.p());
|
|
}
|
|
}
|
|
|
|
if (showGrid) {
|
|
cvf::ref<cvf::DrawableGeo> border = m_3dWellLogGridGeometryGenerator->border();
|
|
if (border.notNull())
|
|
{
|
|
cvf::ref<cvf::Part> part = createPart(border.p(), borderEffect.p());
|
|
if (part.notNull())
|
|
{
|
|
model->addPart(part.p());
|
|
}
|
|
}
|
|
|
|
cvf::ref<cvf::DrawableVectors> normals = m_3dWellLogGridGeometryGenerator->curveNormalVectors();
|
|
if (normals.notNull())
|
|
{
|
|
normals->setSingleColor(gridColor);
|
|
if (RiaApplication::instance()->useShaders())
|
|
{
|
|
normals->setUniformNames("u_transformationMatrix", "u_color");
|
|
}
|
|
|
|
cvf::ref<cvf::Part> part = createPart(normals.p(), curveNormalsEffect.p());
|
|
if (part.notNull())
|
|
{
|
|
model->addPart(part.p());
|
|
}
|
|
}
|
|
}
|
|
}
|