mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
#2703 An initial implementation of filled drawing style with problems remaining.
* New vertices are successfully created in the intersections between the curve and draw surface triangles * New vertices are also inserted along the bottom edge of the filled curve. * However, new vertices will still need to be inserted in the lines connecting the top of the curve and the bottom where they intersect with the triangles. * The option for filled curves remain hidden in the GUI. See #2860. # Please enter the commit message for your changes. Lines starting
This commit is contained in:
Gaute Lindkvist
parent
fba437f595
commit
78326bb19c
@ -135,11 +135,9 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveDrawables(const caf::Display
|
||||
return;
|
||||
}
|
||||
|
||||
m_curveVertices = std::vector<cvf::Vec3f>();
|
||||
m_curveVertices.reserve(interpolatedWellPathPoints.size());
|
||||
|
||||
double plotRangeToResultRangeFactor = planeWidth / (maxClampedResult - minClampedResult);
|
||||
|
||||
m_curveVertices.reserve(interpolatedWellPathPoints.size());
|
||||
for (size_t i = 0; i < interpolatedWellPathPoints.size(); i++)
|
||||
{
|
||||
double scaledResult = 0;
|
||||
@ -151,11 +149,22 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveDrawables(const caf::Display
|
||||
cvf::Vec3d curvePoint(interpolatedWellPathPoints[i] + scaledResult * interpolatedCurveNormals[i]);
|
||||
m_curveVertices.push_back(cvf::Vec3f(curvePoint));
|
||||
}
|
||||
m_curveVertices = projectVerticesOntoTriangles(m_curveVertices, drawSurfaceVertices);
|
||||
|
||||
m_bottomVertices.reserve(m_curveVertices.size() + 2);
|
||||
for (size_t i = 0; i < m_curveVertices.size(); ++i)
|
||||
{
|
||||
double md = m_curveMeasuredDepths[i];
|
||||
cvf::Vec3d point = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathPoints, md);
|
||||
cvf::Vec3d normal = wellPathGeometry()->interpolatedVectorAlongWellPath(wellPathCurveNormals, md);
|
||||
point += planeOffsetFromWellPathCenter * normal;
|
||||
m_bottomVertices.push_back(cvf::Vec3f(point));
|
||||
}
|
||||
m_bottomVertices = projectVerticesOntoTriangles(m_bottomVertices, drawSurfaceVertices);
|
||||
|
||||
projectVerticesOntoTriangles(drawSurfaceVertices);
|
||||
createNewVerticesAlongTriangleEdges(drawSurfaceVertices);
|
||||
|
||||
|
||||
{
|
||||
std::vector<cvf::uint> indices;
|
||||
indices.reserve(m_curveVertices.size() * 2);
|
||||
for (size_t i = 0; i < m_curveVertices.size() - 1; ++i)
|
||||
@ -176,13 +185,42 @@ void Riv3dWellLogCurveGeometryGenerator::createCurveDrawables(const caf::Display
|
||||
m_curveDrawable->setVertexArray(vertexArray.p());
|
||||
}
|
||||
|
||||
{
|
||||
CVF_ASSERT(m_bottomVertices.size() == m_curveVertices.size());
|
||||
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray(m_bottomVertices.size() + m_curveVertices.size());
|
||||
for (size_t i = 0; i < m_bottomVertices.size(); ++i)
|
||||
{
|
||||
(*vertexArray)[2 * i] = m_bottomVertices[i];
|
||||
(*vertexArray)[2 * i + 1] = m_curveVertices[i];
|
||||
}
|
||||
|
||||
std::vector<cvf::uint> indices;
|
||||
indices.reserve(vertexArray->size());
|
||||
for (size_t i = 0; i < vertexArray->size(); ++i)
|
||||
{
|
||||
indices.push_back(cvf::uint(i));
|
||||
}
|
||||
|
||||
cvf::ref<cvf::PrimitiveSetIndexedUInt> indexedUInt = new cvf::PrimitiveSetIndexedUInt(cvf::PrimitiveType::PT_TRIANGLE_STRIP);
|
||||
cvf::ref<cvf::UIntArray> indexArray = new cvf::UIntArray(indices);
|
||||
|
||||
m_curveFilledDrawable = new cvf::DrawableGeo();
|
||||
indexedUInt->setIndices(indexArray.p());
|
||||
m_curveFilledDrawable->addPrimitiveSet(indexedUInt.p());
|
||||
m_curveFilledDrawable->setVertexArray(vertexArray.p());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void Riv3dWellLogCurveGeometryGenerator::clearCurvePointsAndGeometry()
|
||||
{
|
||||
m_curveDrawable = nullptr;
|
||||
m_curveFilledDrawable = nullptr;
|
||||
m_curveVertices.clear();
|
||||
m_bottomVertices.clear();
|
||||
m_curveMeasuredDepths.clear();
|
||||
m_curveValues.clear();
|
||||
}
|
||||
@ -195,6 +233,14 @@ cvf::ref<cvf::DrawableGeo> Riv3dWellLogCurveGeometryGenerator::curveDrawable()
|
||||
return m_curveDrawable;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::ref<cvf::DrawableGeo> Riv3dWellLogCurveGeometryGenerator::curveFilledDrawable()
|
||||
{
|
||||
return m_curveFilledDrawable;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -255,64 +301,58 @@ bool Riv3dWellLogCurveGeometryGenerator::findClosestPointOnCurve(const cvf::Vec3
|
||||
void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongTriangleEdges(const std::vector<cvf::Vec3f>& drawSurfaceVertices)
|
||||
{
|
||||
std::vector<cvf::Vec3f> expandedCurveVertices;
|
||||
std::vector<cvf::Vec3f> expandedBottomVertices;
|
||||
std::vector<double> expandedMeasuredDepths;
|
||||
std::vector<double> expandedValues;
|
||||
size_t estimatedNumberOfPoints = m_curveVertices.size() + drawSurfaceVertices.size();
|
||||
expandedCurveVertices.reserve(estimatedNumberOfPoints);
|
||||
expandedBottomVertices.reserve(estimatedNumberOfPoints);
|
||||
expandedMeasuredDepths.reserve(estimatedNumberOfPoints);
|
||||
expandedValues.reserve(estimatedNumberOfPoints);
|
||||
|
||||
for (size_t i = 0; i < m_curveVertices.size() - 1; i += 2)
|
||||
{
|
||||
if (RigCurveDataTools::isValidValue(m_curveValues[i], false) &&
|
||||
RigCurveDataTools::isValidValue(m_curveValues[i + 1], false))
|
||||
{
|
||||
caf::Line<float> fullSegmentLine(m_curveVertices[i], m_curveVertices[i + 1]);
|
||||
cvf::Vec3f fullSegmentVector = fullSegmentLine.vector();
|
||||
cvf::Vec3f lastVertex = m_curveVertices[i];
|
||||
expandedCurveVertices.push_back(lastVertex);
|
||||
expandedMeasuredDepths.push_back(m_curveMeasuredDepths[i]);
|
||||
expandedValues.push_back(m_curveValues[i]);
|
||||
// Find segments that intersects the triangle edges
|
||||
for (size_t j = 0; j < drawSurfaceVertices.size() - 2; j += 1)
|
||||
{
|
||||
cvf::Vec3f currentSubSegment = m_curveVertices[i + 1] - lastVertex;
|
||||
caf::Line<float> triangleEdge1 = caf::Line<float>(drawSurfaceVertices[j], drawSurfaceVertices[j + 1]);
|
||||
caf::Line<float> triangleEdge2 = caf::Line<float>(drawSurfaceVertices[j + 2], drawSurfaceVertices[j + 1]);
|
||||
cvf::Vec3f triangleNormal = (triangleEdge1.vector().getNormalized() ^ triangleEdge2.vector().getNormalized()).getNormalized();
|
||||
cvf::Vec3f projectedSegmentVector = currentSubSegment - (currentSubSegment * triangleNormal) * triangleNormal;
|
||||
caf::Line<float> projectedCurveLine (lastVertex, lastVertex + projectedSegmentVector);
|
||||
cvf::Vec3f fullSegmentVector = m_curveVertices[i + 1] - m_curveVertices[i];
|
||||
|
||||
// Only attempt to find intersections with the first edge. The other edge is handled with the next triangle.
|
||||
bool withinSegments = false;
|
||||
caf::Line<float> connectingLine = projectedCurveLine.findLineBetweenNearestPoints(triangleEdge1, &withinSegments);
|
||||
if (withinSegments)
|
||||
{
|
||||
cvf::Vec3f newVertex = connectingLine.end();
|
||||
std::vector<cvf::Vec3f> extraVertices;
|
||||
std::vector<cvf::Vec3f> extraBottomVertices;
|
||||
|
||||
cvf::Vec3f newSegmentVector = newVertex - lastVertex;
|
||||
if (newSegmentVector.lengthSquared() < fullSegmentVector.lengthSquared())
|
||||
createNewVerticesAlongSegment(m_curveVertices[i],
|
||||
m_curveVertices[i + 1],
|
||||
drawSurfaceVertices,
|
||||
&extraVertices,
|
||||
&m_bottomVertices[i],
|
||||
&m_bottomVertices[i + 1],
|
||||
&extraBottomVertices);
|
||||
|
||||
CVF_ASSERT(extraVertices.size() == extraBottomVertices.size());
|
||||
|
||||
for (const cvf::Vec3f& extraVertex : extraVertices)
|
||||
{
|
||||
expandedCurveVertices.push_back(newVertex);
|
||||
cvf::Vec3f newSegmentVector = extraVertex - lastVertex;
|
||||
// Scalar projection (a * b / |b|) divided by full segment length to become (a * b / |b|^2)
|
||||
float dotProduct = newSegmentVector * fullSegmentVector;
|
||||
float fractionAlongFullSegment = dotProduct / fullSegmentVector.lengthSquared();
|
||||
float measuredDepth = m_curveMeasuredDepths[i] * (1 - fractionAlongFullSegment) + m_curveMeasuredDepths[i + 1] * fractionAlongFullSegment;
|
||||
float valueAtPoint = m_curveValues[i] * (1 - fractionAlongFullSegment) + m_curveValues[i + 1] * fractionAlongFullSegment;
|
||||
float measuredDepth = m_curveMeasuredDepths[i] * (1 - fractionAlongFullSegment) +
|
||||
m_curveMeasuredDepths[i + 1] * fractionAlongFullSegment;
|
||||
float valueAtPoint =
|
||||
m_curveValues[i] * (1 - fractionAlongFullSegment) + m_curveValues[i + 1] * fractionAlongFullSegment;
|
||||
expandedCurveVertices.push_back(extraVertex);
|
||||
expandedMeasuredDepths.push_back(measuredDepth);
|
||||
expandedValues.push_back(valueAtPoint);
|
||||
lastVertex = newVertex;
|
||||
lastVertex = extraVertex;
|
||||
}
|
||||
expandedBottomVertices.insert(expandedBottomVertices.end(), extraBottomVertices.begin(), extraBottomVertices.end());
|
||||
}
|
||||
}
|
||||
|
||||
// Next original segment point
|
||||
expandedCurveVertices.push_back(m_curveVertices[i + 1]);
|
||||
expandedMeasuredDepths.push_back(m_curveMeasuredDepths[i + 1]);
|
||||
expandedValues.push_back(m_curveValues[i + 1]);
|
||||
}
|
||||
}
|
||||
|
||||
CVF_ASSERT(expandedCurveVertices.size() == expandedBottomVertices.size());
|
||||
m_curveVertices.swap(expandedCurveVertices);
|
||||
m_bottomVertices.swap(expandedBottomVertices);
|
||||
m_curveMeasuredDepths.swap(expandedMeasuredDepths);
|
||||
m_curveValues.swap(expandedValues);
|
||||
}
|
||||
@ -320,9 +360,85 @@ void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongTriangleEdges(con
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles(const std::vector<cvf::Vec3f>& drawSurfaceVertices)
|
||||
void Riv3dWellLogCurveGeometryGenerator::createNewVerticesAlongSegment(const cvf::Vec3f& ptStart,
|
||||
const cvf::Vec3f& ptEnd,
|
||||
const std::vector<cvf::Vec3f>& drawSurfaceVertices,
|
||||
std::vector<cvf::Vec3f>* extraVertices,
|
||||
const cvf::Vec3f* ptBottomStart,
|
||||
const cvf::Vec3f* ptBottomEnd,
|
||||
std::vector<cvf::Vec3f>* extraBottomVertices)
|
||||
{
|
||||
for (size_t i = 0; i < m_curveVertices.size(); ++i)
|
||||
cvf::Vec3f fullSegmentVector = ptEnd - ptStart;
|
||||
extraVertices->push_back(ptStart);
|
||||
|
||||
cvf::Vec3f fullBottomVector;
|
||||
if (ptBottomStart && ptBottomEnd && extraBottomVertices)
|
||||
{
|
||||
fullBottomVector = *ptBottomEnd - *ptBottomStart;
|
||||
extraBottomVertices->push_back(*ptBottomStart);
|
||||
}
|
||||
|
||||
// Find segments that intersects the triangle edges
|
||||
for (size_t j = 0; j < drawSurfaceVertices.size() - 2; j += 1)
|
||||
{
|
||||
caf::Line<float> triangleEdge1 = caf::Line<float>(drawSurfaceVertices[j], drawSurfaceVertices[j + 1]);
|
||||
caf::Line<float> triangleEdge2 = caf::Line<float>(drawSurfaceVertices[j + 2], drawSurfaceVertices[j + 1]);
|
||||
cvf::Vec3f triangleNormal =
|
||||
(triangleEdge1.vector().getNormalized() ^ triangleEdge2.vector().getNormalized()).getNormalized();
|
||||
|
||||
cvf::Vec3f currentSubSegment = ptEnd - extraVertices->back();
|
||||
cvf::Vec3f projectedSegmentVector = currentSubSegment - (currentSubSegment * triangleNormal) * triangleNormal;
|
||||
caf::Line<float> projectedCurveLine(extraVertices->back(), extraVertices->back() + projectedSegmentVector);
|
||||
|
||||
// Only attempt to find intersections with the first edge. The other edge is handled with the next triangle.
|
||||
bool withinSegments = false;
|
||||
caf::Line<float> connectingLine = projectedCurveLine.findLineBetweenNearestPoints(triangleEdge1, &withinSegments);
|
||||
|
||||
cvf::Vec3f newVertex = connectingLine.end();
|
||||
cvf::Vec3f newSegmentVector = newVertex - extraVertices->back();
|
||||
if (withinSegments && newSegmentVector.lengthSquared() < fullSegmentVector.lengthSquared())
|
||||
{
|
||||
extraVertices->push_back(newVertex);
|
||||
|
||||
if (ptBottomStart && ptBottomEnd && extraBottomVertices)
|
||||
{
|
||||
// Do the same for the bottom line, however we need to ensure we add the same amount of points.
|
||||
cvf::Vec3f currentBottomSegment = *ptBottomEnd - extraBottomVertices->back();
|
||||
cvf::Vec3f projectedBottomVector =
|
||||
currentBottomSegment - (currentBottomSegment * triangleNormal) * triangleNormal;
|
||||
caf::Line<float> projectedBottomLine(extraBottomVertices->back(),
|
||||
extraBottomVertices->back() + projectedBottomVector);
|
||||
bool withinBottomSegments = false;
|
||||
|
||||
caf::Line<float> bottomConnectingLine =
|
||||
projectedBottomLine.findLineBetweenNearestPoints(triangleEdge1, &withinBottomSegments);
|
||||
cvf::Vec3f newBottomVertex = bottomConnectingLine.end();
|
||||
cvf::Vec3f newBottomVector = newBottomVertex - extraBottomVertices->back();
|
||||
if (!(withinBottomSegments && newBottomVector.lengthSquared() < fullBottomVector.lengthSquared()))
|
||||
{
|
||||
newBottomVertex = extraBottomVertices->back();
|
||||
}
|
||||
extraBottomVertices->push_back(newBottomVertex);
|
||||
}
|
||||
}
|
||||
}
|
||||
extraVertices->push_back(ptEnd);
|
||||
if (ptBottomStart && ptBottomEnd && extraBottomVertices)
|
||||
{
|
||||
extraBottomVertices->push_back(*ptBottomEnd);
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::vector<cvf::Vec3f>
|
||||
Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles(const std::vector<cvf::Vec3f>& originalVertices,
|
||||
const std::vector<cvf::Vec3f>& drawSurfaceVertices)
|
||||
{
|
||||
std::vector<cvf::Vec3f> projectedVertices;
|
||||
projectedVertices.reserve(originalVertices.size());
|
||||
for (size_t i = 0; i < originalVertices.size(); ++i)
|
||||
{
|
||||
// Sort projections onto triangle by the distance of the projection.
|
||||
std::map<float, cvf::Vec3f> projectionsInsideTriangle;
|
||||
@ -344,20 +460,25 @@ void Riv3dWellLogCurveGeometryGenerator::projectVerticesOntoTriangles(const std:
|
||||
|
||||
bool wasInsideTriangle = false;
|
||||
cvf::Vec3f projectedPoint = projectPointOntoTriangle(
|
||||
m_curveVertices[i], triangleVertex1, triangleVertex2, triangleVertex3, &wasInsideTriangle);
|
||||
originalVertices[i], triangleVertex1, triangleVertex2, triangleVertex3, &wasInsideTriangle);
|
||||
if (wasInsideTriangle)
|
||||
{
|
||||
projectionsInsideTriangle.insert(std::make_pair((projectedPoint - m_curveVertices[i]).lengthSquared(),
|
||||
projectedPoint));
|
||||
projectionsInsideTriangle.insert(
|
||||
std::make_pair((projectedPoint - originalVertices[i]).lengthSquared(), projectedPoint));
|
||||
}
|
||||
}
|
||||
|
||||
// Take the closest projection
|
||||
if (!projectionsInsideTriangle.empty())
|
||||
{
|
||||
m_curveVertices[i] = projectionsInsideTriangle.begin()->second;
|
||||
projectedVertices.push_back(projectionsInsideTriangle.begin()->second);
|
||||
}
|
||||
else
|
||||
{
|
||||
projectedVertices.push_back(originalVertices[i]);
|
||||
}
|
||||
}
|
||||
return projectedVertices;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -395,7 +516,6 @@ cvf::Vec3f Riv3dWellLogCurveGeometryGenerator::projectPointOntoTriangle(const cv
|
||||
v = cvf::Math::clamp(v, 0.0f, 1.0f);
|
||||
w = cvf::Math::clamp(w, 0.0f, 1.0f);
|
||||
projectedPoint = triangleVertex1 * u + triangleVertex2 * v + triangleVertex3 * w;
|
||||
|
||||
}
|
||||
return projectedPoint;
|
||||
}
|
||||
|
||||
@ -59,6 +59,7 @@ public:
|
||||
const RigWellPath* wellPathGeometry() const;
|
||||
|
||||
cvf::ref<cvf::DrawableGeo> curveDrawable();
|
||||
cvf::ref<cvf::DrawableGeo> curveFilledDrawable();
|
||||
|
||||
bool findClosestPointOnCurve(const cvf::Vec3d& globalIntersection,
|
||||
cvf::Vec3d* closestPoint,
|
||||
@ -67,7 +68,15 @@ public:
|
||||
|
||||
private:
|
||||
void createNewVerticesAlongTriangleEdges(const std::vector<cvf::Vec3f>& drawSurfaceVertices);
|
||||
void projectVerticesOntoTriangles(const std::vector<cvf::Vec3f>& drawSurfaceVertices);
|
||||
static void createNewVerticesAlongSegment(const cvf::Vec3f& ptStart,
|
||||
const cvf::Vec3f& ptEnd,
|
||||
const std::vector<cvf::Vec3f>& drawSurfaceVertices,
|
||||
std::vector<cvf::Vec3f>* extraVertices,
|
||||
const cvf::Vec3f* ptBottomStart = nullptr,
|
||||
const cvf::Vec3f* ptBottomEnd = nullptr,
|
||||
std::vector<cvf::Vec3f>* extraBottomVertices = nullptr);
|
||||
|
||||
static std::vector<cvf::Vec3f> projectVerticesOntoTriangles(const std::vector<cvf::Vec3f>& originalVertices, const std::vector<cvf::Vec3f>& drawSurfaceVertices);
|
||||
static cvf::Vec3f projectPointOntoTriangle(const cvf::Vec3f& point,
|
||||
const cvf::Vec3f& triangleVertex1,
|
||||
const cvf::Vec3f& triangleVertex2,
|
||||
@ -77,7 +86,10 @@ private:
|
||||
double m_planeWidth;
|
||||
|
||||
cvf::ref<cvf::DrawableGeo> m_curveDrawable;
|
||||
cvf::ref<cvf::DrawableGeo> m_curveFilledDrawable;
|
||||
std::vector<cvf::Vec3f> m_curveVertices;
|
||||
std::vector<cvf::Vec3f> m_bottomVertices;
|
||||
|
||||
std::vector<double> m_curveMeasuredDepths;
|
||||
std::vector<double> m_curveValues;
|
||||
};
|
||||
|
||||
@ -115,9 +115,9 @@ Riv3dWellLogDrawSurfaceGenerator::createDrawSurface(const caf::DisplayCoordTrans
|
||||
for (size_t i = 0; i < wellPathPoints.size(); i++)
|
||||
{
|
||||
m_vertices.push_back(cvf::Vec3f(
|
||||
wellPathPoints[i] + wellPathSegmentNormals[i] * planeOffsetFromWellPathCenter));
|
||||
wellPathPoints[i] + wellPathSegmentNormals[i] * (planeOffsetFromWellPathCenter - 0.025*planeWidth)));
|
||||
m_vertices.push_back(cvf::Vec3f(
|
||||
wellPathPoints[i] + wellPathSegmentNormals[i] * (planeOffsetFromWellPathCenter + planeWidth)));
|
||||
wellPathPoints[i] + wellPathSegmentNormals[i] * (planeOffsetFromWellPathCenter + 1.025*planeWidth)));
|
||||
}
|
||||
|
||||
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray(m_vertices);
|
||||
|
||||
@ -109,13 +109,10 @@ void Riv3dWellLogPlanePartMgr::append3dWellLogCurveToModel(cvf::ModelBasicList*
|
||||
planeWidth(),
|
||||
drawSurfaceVertices);
|
||||
|
||||
|
||||
cvf::ref<cvf::DrawableGeo> curveDrawable = generator->curveDrawable();
|
||||
|
||||
if (curveDrawable.isNull() || !curveDrawable->boundingBox().isValid())
|
||||
if (curveDrawable.notNull() && curveDrawable->boundingBox().isValid())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
caf::MeshEffectGenerator meshEffectGen(rim3dWellLogCurve->color());
|
||||
meshEffectGen.setLineWidth(2.0f);
|
||||
cvf::ref<cvf::Effect> effect = meshEffectGen.generateCachedEffect();
|
||||
@ -130,6 +127,31 @@ void Riv3dWellLogPlanePartMgr::append3dWellLogCurveToModel(cvf::ModelBasicList*
|
||||
}
|
||||
}
|
||||
|
||||
if (rim3dWellLogCurve->drawStyle() == Rim3dWellLogCurve::FILLED)
|
||||
{
|
||||
Rim3dWellLogCurveCollection* curveCollection = m_wellPath->rim3dWellLogCurveCollection();
|
||||
cvf::ref<RivObjectSourceInfo> sourceInfo = new RivObjectSourceInfo(curveCollection);
|
||||
|
||||
cvf::ref<cvf::DrawableGeo> curveFilledDrawable = generator->curveFilledDrawable();
|
||||
if (curveFilledDrawable.notNull() && curveFilledDrawable->boundingBox().isValid())
|
||||
{
|
||||
caf::SurfaceEffectGenerator filledEffectGen(rim3dWellLogCurve->color(), caf::PO_NONE);
|
||||
filledEffectGen.enableLighting(false);
|
||||
cvf::ref<cvf::Effect> filledEffect = filledEffectGen.generateCachedEffect();
|
||||
|
||||
cvf::ref<cvf::Part> part = new cvf::Part;
|
||||
part->setDrawable(curveFilledDrawable.p());
|
||||
part->setEffect(filledEffect.p());
|
||||
|
||||
if (part.notNull())
|
||||
{
|
||||
model->addPart(part.p());
|
||||
part->setSourceInfo(sourceInfo.p());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -186,6 +208,8 @@ void Riv3dWellLogPlanePartMgr::appendDrawSurfaceToModel(cvf::ModelBasicList*
|
||||
double samplingInterval)
|
||||
{
|
||||
Rim3dWellLogCurveCollection* curveCollection = m_wellPath->rim3dWellLogCurveCollection();
|
||||
cvf::ref<RivObjectSourceInfo> sourceInfo = new RivObjectSourceInfo(curveCollection);
|
||||
|
||||
bool showCoordinateSystemMesh = curveCollection->isShowingGrid();
|
||||
bool showBackground = curveCollection->isShowingBackground();
|
||||
|
||||
@ -216,7 +240,7 @@ void Riv3dWellLogPlanePartMgr::appendDrawSurfaceToModel(cvf::ModelBasicList*
|
||||
cvf::ref<cvf::Effect> curveNormalsEffect = curveNormalsEffectGen.generateCachedEffect();
|
||||
|
||||
cvf::ref<cvf::DrawableGeo> background = m_3dWellLogDrawSurfaceGeometryGenerator->background();
|
||||
cvf::ref<RivObjectSourceInfo> sourceInfo = new RivObjectSourceInfo(curveCollection);
|
||||
|
||||
if (background.notNull())
|
||||
{
|
||||
cvf::ref<cvf::Part> part = createPart(background.p(), backgroundEffect.p());
|
||||
|
||||
@ -51,6 +51,14 @@ namespace caf
|
||||
addItem(Rim3dWellLogCurve::HORIZONTAL_RIGHT, "HORIZONTAL_RIGHT", "Right");
|
||||
setDefault(Rim3dWellLogCurve::VERTICAL_ABOVE);
|
||||
}
|
||||
|
||||
template<>
|
||||
void AppEnum< Rim3dWellLogCurve::DrawStyle >::setUp()
|
||||
{
|
||||
addItem(Rim3dWellLogCurve::LINE, "LINE", "Line");
|
||||
addItem(Rim3dWellLogCurve::FILLED, "FILLED", "Filled");
|
||||
setDefault(Rim3dWellLogCurve::LINE);
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -70,6 +78,7 @@ Rim3dWellLogCurve::Rim3dWellLogCurve()
|
||||
m_maxCurveValue.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
|
||||
|
||||
CAF_PDM_InitField(&m_drawPlane, "DrawPlane", DrawPlaneEnum(VERTICAL_ABOVE), "Draw Plane", "", "", "");
|
||||
CAF_PDM_InitField(&m_drawStyle, "DrawStyle", DrawStyleEnum(LINE), "Draw Style", "", "", "");
|
||||
CAF_PDM_InitField(&m_color, "CurveColor", cvf::Color3f(0.0f, 0.0f, 0.0f), "Curve Color", "", "", "");
|
||||
}
|
||||
|
||||
@ -98,6 +107,14 @@ Rim3dWellLogCurve::DrawPlane Rim3dWellLogCurve::drawPlane() const
|
||||
return m_drawPlane();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
Rim3dWellLogCurve::DrawStyle Rim3dWellLogCurve::drawStyle() const
|
||||
{
|
||||
return m_drawStyle();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
@ -192,6 +209,8 @@ void Rim3dWellLogCurve::configurationUiOrdering(caf::PdmUiOrdering& uiOrdering)
|
||||
{
|
||||
caf::PdmUiGroup* configurationGroup = uiOrdering.addNewGroup("Curve Configuration");
|
||||
configurationGroup->add(&m_drawPlane);
|
||||
// Disable filled draw style in the GUI because of triangle stitching issue #2860.
|
||||
// configurationGroup->add(&m_drawStyle);
|
||||
configurationGroup->add(&m_color);
|
||||
configurationGroup->add(&m_minCurveValue);
|
||||
configurationGroup->add(&m_maxCurveValue);
|
||||
|
||||
@ -50,6 +50,14 @@ public:
|
||||
HORIZONTAL_RIGHT
|
||||
};
|
||||
typedef caf::AppEnum<DrawPlane> DrawPlaneEnum;
|
||||
|
||||
enum DrawStyle
|
||||
{
|
||||
LINE,
|
||||
FILLED
|
||||
};
|
||||
typedef caf::AppEnum<DrawStyle> DrawStyleEnum;
|
||||
|
||||
public:
|
||||
Rim3dWellLogCurve();
|
||||
virtual ~Rim3dWellLogCurve();
|
||||
@ -60,6 +68,7 @@ public:
|
||||
virtual QString resultPropertyString() const = 0;
|
||||
|
||||
DrawPlane drawPlane() const;
|
||||
DrawStyle drawStyle() const;
|
||||
double drawPlaneAngle() const;
|
||||
|
||||
cvf::Color3f color() const;
|
||||
@ -89,7 +98,8 @@ protected:
|
||||
private:
|
||||
void resetMinMaxValues();
|
||||
protected:
|
||||
caf::PdmField<caf::AppEnum<DrawPlane>> m_drawPlane;
|
||||
caf::PdmField<DrawPlaneEnum> m_drawPlane;
|
||||
caf::PdmField<DrawStyleEnum> m_drawStyle;
|
||||
caf::PdmField<cvf::Color3f> m_color;
|
||||
caf::PdmField<double> m_minCurveValue;
|
||||
caf::PdmField<double> m_maxCurveValue;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user