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

3D Well Log Curves: Renaming of the term normals in curve/grid-generation

Browse Source 
* Make it more obvious we are talking about the normals to the 3D well log curve.
This commit is contained in:
Gaute Lindkvist
2018-04-16 10:42:01 +02:00
parent 5e6613d428
commit 092624799e
4 changed files with 22 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeomertyGenerator.cpp
View File

@@ -113,25 +113,25 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
maxZClipHeight = wellPathClipBoundingBox.max().z() + wellPathCollection->wellPathClipZDistance;
}
std::vector<cvf::Vec3d> wellPathNormals = RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle);
std::vector<cvf::Vec3d> wellPathCurveNormals = RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle);
std::vector<cvf::Vec3d> interpolatedWellPathPoints;
std::vector<cvf::Vec3d> interpolatedNormals;
std::vector<cvf::Vec3d> interpolatedCurveNormals;
// Iterate from bottom of well path and up to be able to stop at given Z max clipping height
for (auto md = resultMds.rbegin(); md != resultMds.rend(); md++)
{
cvf::Vec3d point = wellPathGeometry()->interpolatedPointAlongWellPath(*md);
cvf::Vec3d normal = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathNormals, *md);
cvf::Vec3d normal = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathCurveNormals, *md);
if (point.z() > maxZClipHeight) break;
interpolatedWellPathPoints.push_back(point);
interpolatedNormals.push_back(normal.getNormalized());
interpolatedCurveNormals.push_back(normal.getNormalized());
}
if (interpolatedWellPathPoints.empty()) return;
// Reverse list, since it was filled in the opposite order
std::reverse(interpolatedWellPathPoints.begin(), interpolatedWellPathPoints.end());
std::reverse(interpolatedNormals.begin(), interpolatedNormals.end());
std::reverse(interpolatedCurveNormals.begin(), interpolatedCurveNormals.end());
// The result values for the part of the well which is not clipped off, matching interpolatedWellPathPoints size
std::vector<double> resultValuesForInterpolatedPoints(resultValues.end() - interpolatedWellPathPoints.size(),
@@ -152,7 +152,7 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
double plotRangeToResultRangeFactor = planeWidth / (maxResult - minResult);
for (size_t i = 0; i < interpolatedNormals.size(); i++)
for (size_t i = 0; i < interpolatedCurveNormals.size(); i++)
{
double scaledResult = 0;
@@ -163,7 +163,7 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
}
(*vertices)[i] = cvf::Vec3f(
displayCoordTransform->transformToDisplayCoord(interpolatedWellPathPoints[i] + scaledResult * interpolatedNormals[i]));
displayCoordTransform->transformToDisplayCoord(interpolatedWellPathPoints[i] + scaledResult * interpolatedCurveNormals[i]));
}
std::vector<std::pair<size_t, size_t>> valuesIntervals =

18
ApplicationCode/ModelVisualization/Riv3dWellLogGridGeomertyGenerator.cpp
View File

@@ -168,7 +168,7 @@ Riv3dWellLogGridGeometryGenerator::createGrid(const caf::DisplayCoordTransform*
}
{
std::vector<cvf::Vec3d> interpolatedGridPoints;
std::vector<cvf::Vec3d> interpolatedGridNormals;
std::vector<cvf::Vec3d> interpolatedGridCurveNormals;
size_t newStartIndex = originalWellPathSize - wellPathPoints.size();
double firstMd = wellPathGeometry()->m_measuredDepths.at(newStartIndex);
@@ -178,9 +178,9 @@ Riv3dWellLogGridGeometryGenerator::createGrid(const caf::DisplayCoordTransform*
while (md >= firstMd)
{
cvf::Vec3d point = wellPathGeometry()->interpolatedPointAlongWellPath(md);
cvf::Vec3d normal = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathSegmentNormals, md);
cvf::Vec3d curveNormal = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathSegmentNormals, md);
interpolatedGridPoints.push_back(point);
interpolatedGridNormals.push_back(normal.getNormalized());
interpolatedGridCurveNormals.push_back(curveNormal.getNormalized());
md -= gridIntervalSize;
}
@@ -191,13 +191,13 @@ Riv3dWellLogGridGeometryGenerator::createGrid(const caf::DisplayCoordTransform*
indices.reserve(interpolatedGridPoints.size());
cvf::uint indexCounter = 0;
// Normal lines. Start from one to avoid drawing at surface edge.
for (size_t i = 1; i < interpolatedGridNormals.size(); i++)
for (size_t i = 1; i < interpolatedGridCurveNormals.size(); i++)
{
vertices.push_back(cvf::Vec3f(
displayCoordTransform->transformToDisplayCoord(interpolatedGridPoints[i] + interpolatedGridNormals[i] * planeOffsetFromWellPathCenter)));
displayCoordTransform->transformToDisplayCoord(interpolatedGridPoints[i] + interpolatedGridCurveNormals[i] * planeOffsetFromWellPathCenter)));
vertices.push_back(cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(
interpolatedGridPoints[i] + interpolatedGridNormals[i] * (planeOffsetFromWellPathCenter + planeWidth))));
interpolatedGridPoints[i] + interpolatedGridCurveNormals[i] * (planeOffsetFromWellPathCenter + planeWidth))));
indices.push_back(indexCounter++);
indices.push_back(indexCounter++);
@@ -214,7 +214,7 @@ Riv3dWellLogGridGeometryGenerator::createGrid(const caf::DisplayCoordTransform*
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray(vertices);
normalLinesDrawable->setVertexArray(vertexArray.p());
m_normalLines = normalLinesDrawable;
m_curveNormalLines = normalLinesDrawable;
}
return true;
}
@@ -229,9 +229,9 @@ cvf::ref<cvf::DrawableGeo> Riv3dWellLogGridGeometryGenerator::border()
return m_border;
}
cvf::ref<cvf::DrawableGeo> Riv3dWellLogGridGeometryGenerator::normalLines()
cvf::ref<cvf::DrawableGeo> Riv3dWellLogGridGeometryGenerator::curveNormalLines()
{
return m_normalLines;
return m_curveNormalLines;
}
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ModelVisualization/Riv3dWellLogGridGeomertyGenerator.h
View File

@@ -53,7 +53,7 @@ public:
cvf::ref<cvf::DrawableGeo> background();
cvf::ref<cvf::DrawableGeo> border();
cvf::ref<cvf::DrawableGeo> normalLines();
cvf::ref<cvf::DrawableGeo> curveNormalLines();
private:
const RigWellPath* wellPathGeometry() const;
@@ -61,5 +61,5 @@ private:
caf::PdmPointer<RimWellPath> m_wellPath;
cvf::ref<cvf::DrawableGeo> m_background;
cvf::ref<cvf::DrawableGeo> m_border;
cvf::ref<cvf::DrawableGeo> m_normalLines;
cvf::ref<cvf::DrawableGeo> m_curveNormalLines;
};

8
ApplicationCode/ModelVisualization/Riv3dWellLogPlanePartMgr.cpp
View File

@@ -225,7 +225,7 @@ void Riv3dWellLogPlanePartMgr::appendGridToModel(cvf::ModelBasicList*
caf::SurfaceEffectGenerator backgroundEffectGen(cvf::Color4f(1.0, 1.0, 1.0, 1.0), caf::PO_2);
caf::MeshEffectGenerator gridBorderEffectGen(cvf::Color3f(0.4f, 0.4f, 0.4f));
caf::MeshEffectGenerator normalsEffectGen(cvf::Color3f(0.4f, 0.4f, 0.4f));
caf::MeshEffectGenerator curveNormalsEffectGen(cvf::Color3f(0.4f, 0.4f, 0.4f));
backgroundEffectGen.enableLighting(false);
bool gridCreated = m_3dWellLogGridGeometryGenerator->createGrid(displayCoordTransform,
@@ -238,7 +238,7 @@ void Riv3dWellLogPlanePartMgr::appendGridToModel(cvf::ModelBasicList*
cvf::ref<cvf::Effect> backgroundEffect = backgroundEffectGen.generateCachedEffect();
cvf::ref<cvf::Effect> borderEffect = gridBorderEffectGen.generateCachedEffect();
cvf::ref<cvf::Effect> normalsEffect = normalsEffectGen.generateCachedEffect();
cvf::ref<cvf::Effect> curveNormalsEffect = curveNormalsEffectGen.generateCachedEffect();
cvf::ref<cvf::DrawableGeo> background = m_3dWellLogGridGeometryGenerator->background();
if (background.notNull())
@@ -260,10 +260,10 @@ void Riv3dWellLogPlanePartMgr::appendGridToModel(cvf::ModelBasicList*
}
}
cvf::ref<cvf::DrawableGeo> normals = m_3dWellLogGridGeometryGenerator->normalLines();
cvf::ref<cvf::DrawableGeo> normals = m_3dWellLogGridGeometryGenerator->curveNormalLines();
if (normals.notNull())
{
cvf::ref<cvf::Part> part = createPart(normals.p(), normalsEffect.p());
cvf::ref<cvf::Part> part = createPart(normals.p(), curveNormalsEffect.p());
if (part.notNull())
{
model->addPart(part.p());