#2591 3D well log curves: Add grid along well path

ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeomertyGenerator.cpp

@@ -18,13 +18,20 @@
 
 #include "Riv3dWellLogCurveGeomertyGenerator.h"
 
+#include "RigWellPath.h"
+
 #include "cvfPrimitiveSetIndexedUInt.h"
+#include "cafDisplayCoordTransform.h"
+
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-cvf::ref<cvf::DrawableGeo> Riv3dWellLogCurveGeometryGenerator::createDrawable(const std::vector<cvf::Vec3f>& vertices, const std::vector<cvf::uint>& indices) const
+cvf::ref<cvf::DrawableGeo> Riv3dWellLogCurveGeometryGenerator::createCurveLine(const caf::DisplayCoordTransform* displayCoordTransform, const Rim3dWellLogCurve* rim3dWellLogCurve) const
 {
+    std::vector<cvf::Vec3f> vertices = createCurveVertices(rim3dWellLogCurve, displayCoordTransform);
+    std::vector<cvf::uint> indices = createPolylineIndices(vertices.size());
+
     cvf::ref<cvf::PrimitiveSetIndexedUInt> indexedUInt = new cvf::PrimitiveSetIndexedUInt(cvf::PrimitiveType::PT_LINES);
     cvf::ref<cvf::UIntArray>               indexArray = new cvf::UIntArray(indices);
 
@@ -38,3 +45,141 @@ cvf::ref<cvf::DrawableGeo> Riv3dWellLogCurveGeometryGenerator::createDrawable(co
 
     return drawable;
 }
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+cvf::ref<cvf::DrawableGeo> Riv3dWellLogCurveGeometryGenerator::createGrid(const caf::DisplayCoordTransform* displayCoordTransform, const Rim3dWellLogCurve* rim3dWellLogCurve) const
+{
+    std::vector<cvf::Vec3d> wellPathPoints = m_wellPathGeometry->m_wellPathPoints;
+
+    std::vector<cvf::Vec3f> vertices;
+    vertices.reserve(wellPathPoints.size() * 2);
+
+    std::vector<cvf::Vec3d> curveNormals;
+    curveNormals.reserve(wellPathPoints.size());
+
+    for (size_t i = 0; i < wellPathPoints.size() - 1; i++)
+    {
+        cvf::Vec3d z = zForDrawPlane(rim3dWellLogCurve->drawPlane());
+        cvf::Vec3d y = normalBetweenPoints(wellPathPoints[i], wellPathPoints[i + 1], z);
+
+        curveNormals.push_back(y);
+    }
+
+    std::vector<cvf::uint> indices;
+    vertices.reserve(wellPathPoints.size() * 2);
+
+    cvf::uint counter = 0;
+
+    for (size_t i = 0; i < curveNormals.size(); i++)
+    {
+        vertices.push_back(cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(wellPathPoints[i])));
+        vertices.push_back(cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(wellPathPoints[i] + curveNormals[i] * 100)));
+
+        indices.push_back(counter++);
+        indices.push_back(counter++);
+    }
+
+    cvf::ref<cvf::PrimitiveSetIndexedUInt> indexedUInt = new cvf::PrimitiveSetIndexedUInt(cvf::PrimitiveType::PT_LINES);
+    cvf::ref<cvf::UIntArray>               indexArray = new cvf::UIntArray(indices);
+
+    cvf::ref<cvf::DrawableGeo> drawable = new cvf::DrawableGeo();
+
+    indexedUInt->setIndices(indexArray.p());
+    drawable->addPrimitiveSet(indexedUInt.p());
+
+    cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray(vertices);
+    drawable->setVertexArray(vertexArray.p());
+
+    return drawable;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<cvf::Vec3f> Riv3dWellLogCurveGeometryGenerator::createCurveVertices(const Rim3dWellLogCurve* rim3dWellLogCurve, const caf::DisplayCoordTransform* displayCoordTransform) const
+{
+    std::vector<cvf::Vec3d> wellPathPoints;
+    wellPathPoints = m_wellPathGeometry->m_wellPathPoints;
+
+    std::vector<cvf::Vec3f> vertices;
+    vertices.resize(wellPathPoints.size());
+
+    std::vector<cvf::Vec3d> curveNormals;
+    curveNormals.reserve(wellPathPoints.size());
+
+
+    for (size_t i = 0; i < wellPathPoints.size() - 1; i += 2)
+    {
+        cvf::Vec3d z = zForDrawPlane(rim3dWellLogCurve->drawPlane());
+
+        cvf::Vec3d y = normalBetweenPoints(wellPathPoints[i], wellPathPoints[i+1], z);
+
+        curveNormals.push_back(y);
+        curveNormals.push_back(y);
+    }
+
+    for (size_t i = 0; i < curveNormals.size(); i++)
+    {
+        vertices[i] = cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(wellPathPoints[i] + curveNormals[i] * 30));
+    }
+
+    return vertices;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+std::vector<cvf::uint> Riv3dWellLogCurveGeometryGenerator::createPolylineIndices(size_t vertexCount) const
+{
+    std::vector<cvf::uint> indices;
+    indices.resize((vertexCount - 1) * 2);
+
+    cvf::uint counter = 0;
+    for (size_t i = 0; i < indices.size(); i++)
+    {
+        indices[i] = counter;
+        if (i % 2 == 0) counter++;
+    }
+
+    return indices;
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+cvf::Vec3d Riv3dWellLogCurveGeometryGenerator::normalBetweenPoints(const cvf::Vec3d& pt1, const cvf::Vec3d& pt2, const cvf::Vec3d& z) const
+{
+    cvf::Vec3d x = (pt2 - pt1).getNormalized();
+
+    return (z ^ x).getNormalized();
+}
+
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+cvf::Vec3d Riv3dWellLogCurveGeometryGenerator::zForDrawPlane(const Rim3dWellLogCurve::DrawPlane& drawPlane) const
+{
+    if (drawPlane == Rim3dWellLogCurve::HORIZONTAL_LEFT)
+    {
+        return cvf::Vec3d(0, 0, -1);
+    }
+    else if (drawPlane == Rim3dWellLogCurve::HORIZONTAL_RIGHT)
+    {
+        return cvf::Vec3d(0, 0, 1);
+    }
+    else if (drawPlane == Rim3dWellLogCurve::VERTICAL_ABOVE)
+    {
+        return cvf::Vec3d(0, -1, 0);
+    }
+    else if (drawPlane == Rim3dWellLogCurve::VERTICAL_BELOW)
+    {
+        return cvf::Vec3d(0, 1, 0);
+    }
+    else
+    {
+        //Default: Horizontal left
+        return cvf::Vec3d(0, 0, -1);
+    }
+}

ApplicationCode/ModelVisualization/Riv3dWellLogCurveGeomertyGenerator.h

@@ -25,6 +25,8 @@
 
 #include "cafPdmPointer.h"
 
+#include "Rim3dWellLogCurve.h"
+
 #include <vector>
 
 namespace caf
@@ -32,10 +34,25 @@ namespace caf
     class DisplayCoordTransform;
 }
 
+class RigWellPath;
+
 class Riv3dWellLogCurveGeometryGenerator : public cvf::Object
 {
 public:
-    Riv3dWellLogCurveGeometryGenerator() = default;
+    Riv3dWellLogCurveGeometryGenerator(RigWellPath* wellPathGeometry) : m_wellPathGeometry(wellPathGeometry) {};
 
-    cvf::ref<cvf::DrawableGeo> createDrawable(const std::vector<cvf::Vec3f>& vertices, const std::vector<cvf::uint>& indices ) const;
+    cvf::ref<cvf::DrawableGeo> createCurveLine(const caf::DisplayCoordTransform* displayCoordTransform, const Rim3dWellLogCurve* rim3dWellLogCurve) const;
+    cvf::ref<cvf::DrawableGeo> createGrid(const caf::DisplayCoordTransform* displayCoordTransform, const Rim3dWellLogCurve* rim3dWellLogCurve) const;
+
+private:
+    std::vector<cvf::Vec3f> createCurveVertices(const Rim3dWellLogCurve* rim3dWellLogCurve,
+                                                const caf::DisplayCoordTransform* displayCoordTransform) const;
+
+    std::vector<cvf::uint> createPolylineIndices(size_t vertexCount) const;
+
+    cvf::Vec3d normalBetweenPoints(const cvf::Vec3d& pt1, const cvf::Vec3d& pt2, const cvf::Vec3d& z) const;
+    cvf::Vec3d zForDrawPlane(const Rim3dWellLogCurve::DrawPlane& drawPlane) const;
+
+private:
+    cvf::ref<RigWellPath> m_wellPathGeometry;
 };

ApplicationCode/ModelVisualization/Riv3dWellLogPlanePartMgr.cpp

@@ -25,6 +25,8 @@
 #include "cafDisplayCoordTransform.h"
 #include "cafEffectGenerator.h"
 
+#include "cvfColor3.h"
+#include "cvfDrawableGeo.h"
 #include "cvfModelBasicList.h"
 #include "cvfPart.h"
 
@@ -45,20 +47,17 @@ void Riv3dWellLogPlanePartMgr::append3dWellLogCurvesToModel(cvf::ModelBasicList*
 {
     if (rim3dWellLogCurves.empty()) return;
 
-    m_3dWellLogCurveGeometryGenerator = new Riv3dWellLogCurveGeometryGenerator;
-
-    std::vector<cvf::uint> indices = createPolylineIndices(m_wellPathGeometry->m_wellPathPoints.size());
+    m_3dWellLogCurveGeometryGenerator = new Riv3dWellLogCurveGeometryGenerator(m_wellPathGeometry.p());
 
     for (Rim3dWellLogCurve* rim3dWellLogCurve : rim3dWellLogCurves)
     {
-        std::vector<cvf::Vec3f> vertices = createCurveVertices(rim3dWellLogCurve, displayCoordTransform);
-        cvf::ref<cvf::Drawable> drawable = m_3dWellLogCurveGeometryGenerator->createDrawable(vertices, indices);
+        cvf::ref<cvf::Drawable> curveDrawable = m_3dWellLogCurveGeometryGenerator->createCurveLine(displayCoordTransform, rim3dWellLogCurve);
 
         caf::SurfaceEffectGenerator surfaceGen(cvf::Color4f(255, 0, 0, 0.5), caf::PO_1);
         cvf::ref<cvf::Effect> effect = surfaceGen.generateCachedEffect();
 
         cvf::ref<cvf::Part> part = new cvf::Part;
-        part->setDrawable(drawable.p());
+        part->setDrawable(curveDrawable.p());
         part->setEffect(effect.p());
 
         if (part.notNull())
@@ -66,75 +65,19 @@ void Riv3dWellLogPlanePartMgr::append3dWellLogCurvesToModel(cvf::ModelBasicList*
             model->addPart(part.p());
         }
     }
-}
 
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-std::vector<cvf::Vec3f> Riv3dWellLogPlanePartMgr::createCurveVertices(const Rim3dWellLogCurve* rim3dWellLogCurve, 
-                                                                      const caf::DisplayCoordTransform* displayCoordTransform)
-{
-    std::vector<cvf::Vec3d> wellPathPoints = m_wellPathGeometry->m_wellPathPoints;
+    //TODO: Atm, only the grid for the first curve is drawn.
+    cvf::ref<cvf::Drawable> gridDrawable = m_3dWellLogCurveGeometryGenerator->createGrid(displayCoordTransform, rim3dWellLogCurves[0]);
 
-    std::vector<cvf::Vec3f> vertices;
-    vertices.resize(wellPathPoints.size());
+    caf::SurfaceEffectGenerator surfaceGen(cvf::Color4f(255, 255, 0, 1), caf::PO_1);
+    cvf::ref<cvf::Effect> effect = surfaceGen.generateCachedEffect();
 
-    std::vector<cvf::Vec3d> curveNormals;
-    curveNormals.reserve(wellPathPoints.size());
+    cvf::ref<cvf::Part> part = new cvf::Part;
+    part->setDrawable(gridDrawable.p());
+    part->setEffect(effect.p());
 
-    for (size_t i = 0; i < wellPathPoints.size() - 1; i++)
+    if (part.notNull())
     {
-        cvf::Vec3d wellPathSegment = wellPathPoints[i + 1] - wellPathPoints[i];
-        
-        cvf::Vec3d normVec;
-        if (rim3dWellLogCurve->drawPlane() == Rim3dWellLogCurve::HORIZONTAL_LEFT)
-        {
-            normVec = -wellPathSegment.perpendicularVector();
-        }
-        else
-        {
-            normVec = wellPathSegment.perpendicularVector();
-        }
-        curveNormals.push_back((wellPathSegment ^ normVec).getNormalized()*30);
+        model->addPart(part.p());
     }
-
-    cvf::Vec3d wellPathSegment = wellPathPoints[wellPathPoints.size()-1] - wellPathPoints[wellPathPoints.size() - 2];
-    cvf::Vec3d normVec = wellPathSegment.perpendicularVector();
-    curveNormals.push_back((wellPathSegment ^ normVec).getNormalized() * 30);
-
-    for (size_t i = 0; i < curveNormals.size(); i++)
-    {
-        cvf::Mat4d transMat;
-        transMat.setTranslation(curveNormals[i]);
-
-        vertices[i] = cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(wellPathPoints[i].getTransformedPoint(transMat)));
-    }
-
-//     cvf::Mat4d transMat;
-//     transMat.setTranslation(cvf::Vec3d(0, 0, 10));
-// 
-//     for (size_t i = 0; i < wellPathPoints.size(); i++)
-//     {
-//         vertices[i] = cvf::Vec3f(displayCoordTransform->transformToDisplayCoord(wellPathPoints[i].getTransformedPoint(transMat)));
-//     }
-
-    return vertices;
-}
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-std::vector<cvf::uint> Riv3dWellLogPlanePartMgr::createPolylineIndices(size_t vertexCount)
-{
-    std::vector<cvf::uint> indices;
-    indices.resize((vertexCount - 1) * 2);
-
-    cvf::uint counter = 0;
-    for (size_t i = 0; i < indices.size(); i++)
-    {
-        indices[i] = counter;
-        if (i % 2 == 0) counter++;
-    }
-
-    return indices;
 }

ApplicationCode/ModelVisualization/Riv3dWellLogPlanePartMgr.h

@@ -20,7 +20,6 @@
 
 #include "cvfBase.h"
 #include "cvfObject.h"
-#include "cvfVector3.h"
 
 #include "Rim3dWellLogCurve.h"
 
@@ -31,7 +30,6 @@
 namespace cvf
 {
     class ModelBasicList;
-    class Part;
 }
 
 namespace caf
@@ -50,10 +48,6 @@ public:
     void append3dWellLogCurvesToModel(cvf::ModelBasicList* model, 
                                       const caf::DisplayCoordTransform* displayCoordTransform,
                                       std::vector<Rim3dWellLogCurve*>   rim3dWellLogCurves);
-private:
-    std::vector<cvf::Vec3f> createCurveVertices(const Rim3dWellLogCurve* rim3dWellLogCurve,
-                                                const caf::DisplayCoordTransform* displayCoordTransform);
-    std::vector<cvf::uint>  createPolylineIndices(size_t vertexCount);
 
 private:
     cvf::ref<Riv3dWellLogCurveGeometryGenerator> m_3dWellLogCurveGeometryGenerator;