Moved remaining code from RimWellLogCurveImpl to RigWellLogCurveData

Removed class RimWellLogCurveImpl.
RigWellLogCurveData::calculateValidPointsIntervals() needs to be
harmonized with new way of extracting depths from well paths.

ApplicationCode/ProjectDataModel/CMakeLists_files.cmake

@@ -68,7 +68,6 @@ ${CEE_CURRENT_LIST_DIR}RimWellLogPlotCurve.h
 ${CEE_CURRENT_LIST_DIR}RimViewLinker.h
 ${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.h
 ${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.h
-${CEE_CURRENT_LIST_DIR}RimWellLogCurveImpl.h
 ${CEE_CURRENT_LIST_DIR}RimWellLogFile.h
 ${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.h
 ${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.h
@@ -138,7 +137,6 @@ ${CEE_CURRENT_LIST_DIR}RimWellLogPlotCurve.cpp
 ${CEE_CURRENT_LIST_DIR}RimViewLinker.cpp
 ${CEE_CURRENT_LIST_DIR}RimViewLinkerCollection.cpp
 ${CEE_CURRENT_LIST_DIR}RimWellLogExtractionCurve.cpp
-${CEE_CURRENT_LIST_DIR}RimWellLogCurveImpl.cpp
 ${CEE_CURRENT_LIST_DIR}RimWellLogFile.cpp
 ${CEE_CURRENT_LIST_DIR}RimWellLogFileChannel.cpp
 ${CEE_CURRENT_LIST_DIR}RimWellLogFileCurve.cpp

ApplicationCode/ProjectDataModel/RimWellLogCurveImpl.cpp

@@ -1,162 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) 2015-     Statoil ASA
-//  Copyright (C) 2015-     Ceetron Solutions AS
-// 
-//  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 "RimWellLogCurveImpl.h"
-
-#include "cvfBase.h"
-#include "cvfMath.h"
-#include "cvfAssert.h"
-
-#include <cmath> // Needed for HUGE_VAL on Linux
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-void RimWellLogCurveImpl::validCurvePointIntervals(const std::vector<double>& depthValues, const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals)
-{
-    std::vector< std::pair<size_t, size_t> > valuesIntervals;
-    calculateIntervalsOfValidValues(values, valuesIntervals);
-
-    intervals = valuesIntervals;
-
-    // TODO: The following code does not work as expected
-    // See issue #459 (original issue) and bugs #557 #560 and #561
-    // Suggestion: Remove code related to filtering out depth values,
-    // because we want to see the value difference at element borders
-
-/*
-    size_t intervalsCount = valuesIntervals.size();
-    for (size_t intIdx = 0; intIdx < intervalsCount; intIdx++)
-    {
-        std::vector< std::pair<size_t, size_t> > depthValuesIntervals;
-        validDepthValuesIntervals(depthValues, valuesIntervals[intIdx].first, valuesIntervals[intIdx].second, depthValuesIntervals);
-
-        for (size_t dvintIdx = 0; dvintIdx < depthValuesIntervals.size(); dvintIdx++)
-        {
-            intervals.push_back(depthValuesIntervals[dvintIdx]);
-        }
-    }
-*/
-}
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-void RimWellLogCurveImpl::calculateIntervalsOfValidValues(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals)
-{
-    int startIdx = -1;
-    size_t vIdx = 0;
-
-    size_t valueCount = values.size();
-    while (vIdx < valueCount)
-    {
-        double value = values[vIdx];
-        if (value == HUGE_VAL || value == -HUGE_VAL || value != value)
-        {
-            if (startIdx >= 0)
-            {
-                intervals.push_back(std::make_pair(startIdx, vIdx - 1));
-                startIdx = -1;
-            }
-        }
-        else if (startIdx < 0)
-        {
-            startIdx = (int)vIdx;
-        }
-
-        vIdx++;
-    }
-
-    if (startIdx >= 0 && startIdx < ((int)valueCount))
-    {
-        intervals.push_back(std::make_pair(startIdx, valueCount - 1));
-    }
-}
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-void RimWellLogCurveImpl::validDepthValuesIntervals(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >& intervals)
-{
-    if (startIdx > stopIdx)
-    {
-        return;
-    }
-
-    if (startIdx == stopIdx || stopIdx - startIdx == 1)
-    {
-        intervals.push_back(std::make_pair(startIdx, stopIdx));
-        return;
-    }
-
-    // !! TODO: Find a reasonable tolerance
-    const double depthDiffTolerance = 0.1;
-
-    // Find intervals containing depth values that should be connected
-    size_t intStartIdx = startIdx;
-    for (size_t vIdx = startIdx + 1; vIdx < stopIdx; vIdx += 2)
-    {
-        if (cvf::Math::abs(depthValues[vIdx + 1] - depthValues[vIdx]) > depthDiffTolerance)
-        {
-            intervals.push_back(std::make_pair(intStartIdx, vIdx));
-            intStartIdx = vIdx + 1;
-        }
-    }
-
-    if (intStartIdx <= stopIdx)
-    {
-        intervals.push_back(std::make_pair(intStartIdx, stopIdx));
-    }
-}
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-void RimWellLogCurveImpl::addValuesFromIntervals(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues)
-{
-    CVF_ASSERT(filteredValues);
-
-    for (size_t intIdx = 0; intIdx < intervals.size(); intIdx++)
-    {
-        for (size_t vIdx = intervals[intIdx].first; vIdx <= intervals[intIdx].second; vIdx++)
-        {
-            filteredValues->push_back(values[vIdx]);
-        }
-    }
-}
-
-//--------------------------------------------------------------------------------------------------
-/// 
-//--------------------------------------------------------------------------------------------------
-void RimWellLogCurveImpl::filteredIntervals(const std::vector< std::pair<size_t, size_t> >& intervals, std::vector< std::pair<size_t, size_t> >* fltrIntervals)
-{
-    CVF_ASSERT(fltrIntervals);
-
-    const size_t intervalCount = intervals.size();
-    if (intervalCount < 1) return;
-
-    size_t index = 0;
-    for (size_t intIdx = 0; intIdx < intervalCount; intIdx++)
-    {
-        size_t intervalSize = intervals[intIdx].second - intervals[intIdx].first + 1;
-        fltrIntervals->push_back(std::make_pair(index, index + intervalSize - 1));
-
-        index += intervalSize;
-    }
-}

ApplicationCode/ProjectDataModel/RimWellLogCurveImpl.h

@@ -1,40 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-//  Copyright (C) 2015-     Statoil ASA
-//  Copyright (C) 2015-     Ceetron Solutions AS
-// 
-//  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.
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include <vector>
-#include <cstddef>
-
-
-//==================================================================================================
-///  
-///  
-//==================================================================================================
-class RimWellLogCurveImpl
-{
-public:
-    static void calculateIntervalsOfValidValues(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals);
-    static void validDepthValuesIntervals(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >& intervals);
-    static void validCurvePointIntervals(const std::vector<double>& depthValues, const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals);
-    static void addValuesFromIntervals(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues);
-    static void filteredIntervals(const std::vector< std::pair<size_t, size_t> >& intervals, std::vector< std::pair<size_t, size_t> >* fltrIntervals);
-};
-
-

ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp

@@ -18,7 +18,6 @@
 /////////////////////////////////////////////////////////////////////////////////
 
 #include "RimWellLogExtractionCurve.h"
-#include "RimWellLogCurveImpl.h"
 
 #include "RiaApplication.h"
 

ApplicationCode/ProjectDataModel/RimWellLogFileCurve.cpp

@@ -27,7 +27,6 @@
 #include "RimWellLogFile.h"
 #include "RimWellLogPlotTrack.h"
 #include "RimWellLogPlot.h"
-#include "RimWellLogCurveImpl.h"
 
 #include "RiuWellLogTrackPlot.h"
 #include "RiuWellLogPlotCurve.h"

ApplicationCode/ReservoirDataModel/RigWellLogCurveData.cpp

@@ -19,6 +19,9 @@
 
 #include "RigWellLogCurveData.h"
 
+#include "cvfMath.h"
+#include "cvfAssert.h"
+
 #include <cmath>
 
 //--------------------------------------------------------------------------------------------------
@@ -45,7 +48,7 @@ void RigWellLogCurveData::setPoints(const std::vector<double>& xValues, const st
     m_xValues = xValues;
     m_yValues = yValues;
     
-    calculateValidXValuesIntervals();
+    calculateValidPointsIntervals();
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -69,7 +72,7 @@ const std::vector<double>& RigWellLogCurveData::yValues() const
 //--------------------------------------------------------------------------------------------------
 const std::vector< std::pair<size_t, size_t> >& RigWellLogCurveData::filteredIntervals() const
 {
-    return m_validXValuesIntervals;
+    return m_validPointsIntervals;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -78,7 +81,7 @@ const std::vector< std::pair<size_t, size_t> >& RigWellLogCurveData::filteredInt
 std::vector<double> RigWellLogCurveData::validXValues() const
 {
     std::vector<double> filteredValues;
-    pickValuesFromIntervals(m_xValues, m_validXValuesIntervals, &filteredValues);
+    getValuesByIntervals(m_xValues, m_validPointsIntervals, &filteredValues);
 
     return filteredValues;
 }
@@ -89,7 +92,7 @@ std::vector<double> RigWellLogCurveData::validXValues() const
 std::vector<double> RigWellLogCurveData::validYValues() const
 {
     std::vector<double> filteredValues;
-    pickValuesFromIntervals(m_yValues, m_validXValuesIntervals, &filteredValues);
+    getValuesByIntervals(m_yValues, m_validPointsIntervals, &filteredValues);
 
     return filteredValues;
 }
@@ -100,7 +103,7 @@ std::vector<double> RigWellLogCurveData::validYValues() const
 std::vector< std::pair<size_t, size_t> > RigWellLogCurveData::validPointsIntervals() const
 {
     std::vector< std::pair<size_t, size_t> > intervals;
-    computeFilteredIntervals(m_validXValuesIntervals, &intervals);
+    computeFilteredIntervals(m_validPointsIntervals, &intervals);
 
     return intervals;
 }
@@ -109,9 +112,26 @@ std::vector< std::pair<size_t, size_t> > RigWellLogCurveData::validPointsInterva
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RigWellLogCurveData::calculateValidXValuesIntervals()
+void RigWellLogCurveData::calculateValidPointsIntervals()
 {
-    calculateIntervalsOfValidValues(m_xValues, &m_validXValuesIntervals);
+    std::vector< std::pair<size_t, size_t> > valuesIntervals;
+    calculateIntervalsOfValidValues(m_xValues, &valuesIntervals);
+
+    std::vector< std::pair<size_t, size_t> > pointsIntervals;
+
+    size_t intervalsCount = valuesIntervals.size();
+    for (size_t intIdx = 0; intIdx < intervalsCount; intIdx++)
+    {
+        std::vector< std::pair<size_t, size_t> > depthValuesIntervals;
+        calculateIntervalsOfValidDepthValues(m_yValues, valuesIntervals[intIdx].first, valuesIntervals[intIdx].second, &depthValuesIntervals);
+
+        for (size_t dvintIdx = 0; dvintIdx < depthValuesIntervals.size(); dvintIdx++)
+        {
+            pointsIntervals.push_back(depthValuesIntervals[dvintIdx]);
+        }
+    }
+
+    m_validPointsIntervals = pointsIntervals;
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -150,11 +170,49 @@ void RigWellLogCurveData::calculateIntervalsOfValidValues(const std::vector<doub
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+/// 
+//--------------------------------------------------------------------------------------------------
+void RigWellLogCurveData::calculateIntervalsOfValidDepthValues(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >* intervals)
+{
+    CVF_ASSERT(intervals);
+
+    if (startIdx > stopIdx)
+    {
+        return;
+    }
+
+    if (startIdx == stopIdx || stopIdx - startIdx == 1)
+    {
+        intervals->push_back(std::make_pair(startIdx, stopIdx));
+        return;
+    }
+
+    // !! TODO: Find a reasonable tolerance
+    const double depthDiffTolerance = 0.1;
+
+    // Find intervals containing depth values that should be connected
+    size_t intStartIdx = startIdx;
+    for (size_t vIdx = startIdx + 1; vIdx < stopIdx; vIdx += 2)
+    {
+        if (cvf::Math::abs(depthValues[vIdx + 1] - depthValues[vIdx]) > depthDiffTolerance)
+        {
+            intervals->push_back(std::make_pair(intStartIdx, vIdx));
+            intStartIdx = vIdx + 1;
+        }
+    }
+
+    if (intStartIdx <= stopIdx)
+    {
+        intervals->push_back(std::make_pair(intStartIdx, stopIdx));
+    }
+}
+
 
 //--------------------------------------------------------------------------------------------------
 /// 
 //--------------------------------------------------------------------------------------------------
-void RigWellLogCurveData::pickValuesFromIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues)
+void RigWellLogCurveData::getValuesByIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues)
 {
     CVF_ASSERT(filteredValues);
 

ApplicationCode/ReservoirDataModel/RigWellLogCurveData.h

@@ -46,16 +46,17 @@ public:
     std::vector< std::pair<size_t, size_t> >        validPointsIntervals() const;
 
 private:
-    void        calculateValidXValuesIntervals();
+    void        calculateValidPointsIntervals();
 
     static void calculateIntervalsOfValidValues(const std::vector<double>& values, std::vector< std::pair<size_t, size_t> >* intervals);
-    static void pickValuesFromIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues);
+    static void calculateIntervalsOfValidDepthValues(const std::vector<double>& depthValues, size_t startIdx, size_t stopIdx, std::vector< std::pair<size_t, size_t> >* intervals);
+    static void getValuesByIntervals(const std::vector<double>& values, const std::vector< std::pair<size_t, size_t> >& intervals, std::vector<double>* filteredValues);
     static void computeFilteredIntervals(const std::vector< std::pair<size_t, size_t> >& intervals, std::vector< std::pair<size_t, size_t> >* filteredIntervals);
 
 private:
     std::vector<double>                         m_xValues;
     std::vector<double>                         m_yValues;
-    std::vector< std::pair<size_t, size_t> >    m_validXValuesIntervals;
+    std::vector< std::pair<size_t, size_t> >    m_validPointsIntervals;
 
 friend class RigWellLogCurveDataTestInterface;
 };