OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2026-09-03 20:53:13 -05:00
Code Issues Packages Projects Releases Wiki Activity

3D Well log curves: Use the new generalized interpolation for normals

Browse Source 
* Don't have to perform the normal generation again for grid points.
This commit is contained in:
Gaute Lindkvist
2018-04-13 14:56:19 +02:00
parent 1bb1b3004e
commit b48adbbaa9
4 changed files with 41 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeomertyGenerator.cpp
+7 -9
View File
@@ -113,15 +113,19 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
maxZClipHeight = wellPathClipBoundingBox.max().z() + wellPathCollection->wellPathClipZDistance;
}
std::vector<cvf::Vec3d> interpolatedWellPathPoints;
std::vector<cvf::Vec3d> wellPathNormals = RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle);
std::vector<cvf::Vec3d> interpolatedWellPathPoints;
std::vector<cvf::Vec3d> interpolatedNormals;
// 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);
if (point.z() > maxZClipHeight) break;
interpolatedWellPathPoints.push_back(point);
interpolatedNormals.push_back(normal.getNormalized());
}
if (interpolatedWellPathPoints.empty()) return;
@@ -132,12 +136,6 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
std::vector<double> resultValuesForInterpolatedPoints(resultValues.end() - interpolatedWellPathPoints.size(),
resultValues.end());
std::vector<cvf::Vec3d> pairsOfWellPathPoints;
RigWellPathGeometryTools::calculatePairsOfClosestSamplingPointsAlongWellPath(wellPathGeometry(), interpolatedWellPathPoints, &pairsOfWellPathPoints);
std::vector<cvf::Vec3d> pointNormals = RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle, pairsOfWellPathPoints, RigWellPathGeometryTools::LINE_SEGMENTS);
if (interpolatedWellPathPoints.size() != pointNormals.size()) return;
double maxResult = -HUGE_VAL;
double minResult = HUGE_VAL;
@@ -153,7 +151,7 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
double plotRangeToResultRangeFactor = planeWidth / (maxResult - minResult);
for (size_t i = 0; i < pointNormals.size(); i++)
for (size_t i = 0; i < interpolatedNormals.size(); i++)
{
double scaledResult = 0;
@@ -164,7 +162,7 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveVerticesAndIndices(const std
}
(*vertices)[i] = cvf::Vec3f(
displayCoordTransform->transformToDisplayCoord(interpolatedWellPathPoints[i] + scaledResult * pointNormals[i]));
displayCoordTransform->transformToDisplayCoord(interpolatedWellPathPoints[i] + scaledResult * interpolatedNormals[i]));
}
std::vector<std::pair<size_t, size_t>> valuesIntervals =
ApplicationCode/ModelVisualization/Riv3dWellLogGridGeomertyGenerator.cpp
+25 -33
View File
@@ -92,42 +92,17 @@ Riv3dWellLogGridGeometryGenerator::createGrid(const caf::DisplayCoordTransform*
std::map< DrawableId, cvf::ref<cvf::DrawableGeo> > drawables;
std::vector<cvf::Vec3d> gridPoints;
size_t newStartIndex = originalWellPathSize - wellPathPoints.size();
double firstMd = wellPathGeometry()->m_measuredDepths.at(newStartIndex);
double lastMd = wellPathGeometry()->m_measuredDepths.back();
double md = lastMd;
while (md >= firstMd)
{
cvf::Vec3d point = wellPathGeometry()->interpolatedPointAlongWellPath(md);
gridPoints.push_back(point);
md -= gridIntervalSize;
}
std::vector<cvf::Vec3d> pointNormals;
std::vector<cvf::Vec3d> closestPoints;
RigWellPathGeometryTools::calculatePairsOfClosestSamplingPointsAlongWellPath(wellPathGeometry(), gridPoints, &closestPoints);
pointNormals = RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle, closestPoints, RigWellPathGeometryTools::LINE_SEGMENTS);
if (pointNormals.size() != gridPoints.size())
{
return std::map< DrawableId, cvf::ref<cvf::DrawableGeo> >();
}
// calculateLineSegmentNormals returns normals for the whole well path. Erase the part which is clipped off
std::vector<cvf::Vec3d> wellPathSegmentNormals =
RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle, wellPathGeometry()->m_wellPathPoints, RigWellPathGeometryTools::POLYLINE);
RigWellPathGeometryTools::calculateLineSegmentNormals(wellPathGeometry(), planeAngle);
wellPathSegmentNormals.erase(wellPathSegmentNormals.begin(), wellPathSegmentNormals.end() - wellPathPoints.size());
{
std::vector<cvf::Vec3f> vertices;
vertices.reserve(gridPoints.size());
vertices.reserve(wellPathPoints.size());
std::vector<cvf::uint> indices;
indices.reserve(gridPoints.size());
indices.reserve(wellPathPoints.size());
cvf::uint indexCounter = 0;
// Line along and close to well
for (size_t i = 0; i < wellPathPoints.size(); i++)
@@ -162,20 +137,37 @@ Riv3dWellLogGridGeometryGenerator::createGrid(const caf::DisplayCoordTransform*
drawables[GridBorder] = gridBorderDrawable;
}
{
std::vector<cvf::Vec3d> interpolatedGridPoints;
std::vector<cvf::Vec3d> interpolatedGridNormals;
size_t newStartIndex = originalWellPathSize - wellPathPoints.size();
double firstMd = wellPathGeometry()->m_measuredDepths.at(newStartIndex);
double lastMd = wellPathGeometry()->m_measuredDepths.back();
double md = lastMd;
while (md >= firstMd)
{
cvf::Vec3d point = wellPathGeometry()->interpolatedPointAlongWellPath(md);
cvf::Vec3d normal = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathSegmentNormals, md);
interpolatedGridPoints.push_back(point);
interpolatedGridNormals.push_back(normal.getNormalized());
md -= gridIntervalSize;
}
std::vector<cvf::Vec3f> vertices;
vertices.reserve(gridPoints.size());
vertices.reserve(interpolatedGridPoints.size());
std::vector<cvf::uint> indices;
indices.reserve(gridPoints.size());
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 < pointNormals.size(); i++)
for (size_t i = 1; i < interpolatedGridNormals.size(); i++)
{
vertices.push_back(cvf::Vec3f(
displayCoordTransform->transformToDisplayCoord(gridPoints[i] + pointNormals[i] * planeOffsetFromWellPathCenter)));
displayCoordTransform->transformToDisplayCoord(interpolatedGridPoints[i] + interpolatedGridNormals[i] * planeOffsetFromWellPathCenter)));
vertices.push_back(cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(
gridPoints[i] + pointNormals[i] * (planeOffsetFromWellPathCenter + planeWidth))));
interpolatedGridPoints[i] + interpolatedGridNormals[i] * (planeOffsetFromWellPathCenter + planeWidth))));
indices.push_back(indexCounter++);
indices.push_back(indexCounter++);