Grid geometry extraction for Webviz

.github/workflows/ResInsightWithCache.yml

@@ -25,7 +25,7 @@ jobs:
       matrix:
         config:
           - {
-              name: "Windows Latest MSVC",
+              name: "Windows_Latest_MSVC",
               os: windows-2022,
               cc: "cl",
               cxx: "cl",
@@ -38,7 +38,7 @@ jobs:
               publish-to-pypi: false,
             }
           - {
-              name: "Ubuntu 20.04 gcc",
+              name: "Ubuntu_20.04_gcc",
               os: ubuntu-20.04,
               cc: "gcc",
               cxx: "g++",
@@ -51,7 +51,7 @@ jobs:
               publish-to-pypi: true,
             }
           - {
-              name: "Ubuntu 22.04 clang-16",
+              name: "Ubuntu_22.04_clang-16",
               os: ubuntu-22.04,
               cc: "clang-16",
               cxx: "clang++-16",

ApplicationExeCode/RiaMain.cpp

@@ -17,7 +17,9 @@
 /////////////////////////////////////////////////////////////////////////////////
 
 #include "RiaArgumentParser.h"
+#include "RiaLogging.h"
 #include "RiaMainTools.h"
+#include "RiaOpenMPTools.h"
 #include "RiaPreferences.h"
 
 #ifdef ENABLE_GRPC
@@ -139,6 +141,9 @@ int main( int argc, char* argv[] )
 
     RiaApplication::ApplicationStatus status = app->handleArguments( &progOpt );
 
+    int numOmpThreads = RiaOpenMPTools::numberOfThreads();
+    RiaLogging::info( QString( "OpenMP Num Threads: %1\n" ).arg( numOmpThreads ) );
+
     if ( status == RiaApplication::ApplicationStatus::EXIT_COMPLETED )
     {
         // Make sure project is closed to avoid assert and crash in destruction of widgets

ApplicationLibCode/Application/Tools/RiaLogging.cpp

@@ -358,7 +358,7 @@ void RiuMessageLoggerBase::writeMessageWithPrefixToLogger( const char* prefix, c
 //--------------------------------------------------------------------------------------------------
 void RiaStdOutLogger::writeMessageToLogger( const std::string& str )
 {
-    std::cout << str;
+    std::cout << str << std::flush;
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/Application/Tools/RiaOpenMPTools.cpp

@@ -48,3 +48,22 @@ int RiaOpenMPTools::currentThreadIndex()
 
     return myThread;
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+int RiaOpenMPTools::numberOfThreads()
+{
+    int numberOfThreads = 1;
+
+#ifdef USE_OPENMP
+
+#pragma omp parallel
+    {
+        numberOfThreads = omp_get_num_threads();
+    }
+
+#endif
+
+    return numberOfThreads;
+}

ApplicationLibCode/Application/Tools/RiaOpenMPTools.h

@@ -27,4 +27,5 @@ namespace RiaOpenMPTools
 {
 int availableThreadCount();
 int currentThreadIndex();
+int numberOfThreads();
 }; // namespace RiaOpenMPTools

ApplicationLibCode/ModelVisualization/Intersections/CMakeLists_files.cmake

@@ -11,6 +11,8 @@ set(SOURCE_GROUP_HEADER_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RivEclipseIntersectionGrid.h
     ${CMAKE_CURRENT_LIST_DIR}/RivFemIntersectionGrid.h
     ${CMAKE_CURRENT_LIST_DIR}/RivIntersectionGeometryGeneratorInterface.h
+    ${CMAKE_CURRENT_LIST_DIR}/RivPolylineIntersectionGeometryGenerator.h
+    ${CMAKE_CURRENT_LIST_DIR}/RivEnclosingPolygonGenerator.h
 )
 
 set(SOURCE_GROUP_SOURCE_FILES
@@ -24,6 +26,8 @@ set(SOURCE_GROUP_SOURCE_FILES
     ${CMAKE_CURRENT_LIST_DIR}/RivSectionFlattener.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RivEclipseIntersectionGrid.cpp
     ${CMAKE_CURRENT_LIST_DIR}/RivFemIntersectionGrid.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RivPolylineIntersectionGeometryGenerator.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/RivEnclosingPolygonGenerator.cpp
 )
 
 list(APPEND CODE_HEADER_FILES ${SOURCE_GROUP_HEADER_FILES})

ApplicationLibCode/ModelVisualization/Intersections/RivEclipseIntersectionGrid.cpp

@@ -68,9 +68,14 @@ bool RivEclipseIntersectionGrid::useCell( size_t cellIndex ) const
     {
         const RigCell& cell = m_mainGrid->globalCellArray()[cellIndex];
         if ( m_showInactiveCells )
+        {
             return !cell.isInvalid() && ( cell.subGrid() == nullptr );
-        else
+        }
+        if ( m_activeCellInfo.p() != nullptr )
+        {
             return m_activeCellInfo->isActive( cellIndex ) && ( cell.subGrid() == nullptr );
+        }
+        return true;
     }
     return false;
 }

ApplicationLibCode/ModelVisualization/Intersections/RivEnclosingPolygonGenerator.cpp

@@ -0,0 +1,176 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2024-     Equinor ASA
+//
+//  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 "RivEnclosingPolygonGenerator.h"
+#include "cvfMath.h"
+
+#include <algorithm>
+#include <map>
+
+RivEnclosingPolygonGenerator::RivEnclosingPolygonGenerator()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RivEnclosingPolygonGenerator::constructEnclosingPolygon()
+{
+    // Construct the enclosing polygon from the edges
+    //
+    // d ________ c
+    //   |     /|
+    //   |    / |
+    //   |   /  |
+    //   |  /   |
+    //   | /    |
+    //   |/_____|
+    //  a        b
+    //
+    //  The line segment ca/ac is the only edge that is not part of the enclosing polygon
+    //  This line segment will occur twice in the list of edges as it is present in both triangles
+    //  (a, b, c) and (a, c, d).
+    //  The line segment ca/ac will be removed from the list of for the enclosing polygon
+    //
+    // Enclosing edges are defined as edges only occurring once in the list of edges
+    //
+
+    // Must have at least 3 edges to construct a polygon
+    CVF_ASSERT( isValidPolygon() );
+
+    // Map of edge key and number of occurrences
+    std::map<cvf::uint64, cvf::uint> edgeKeysAndCount;
+
+    // Extract boundary edge keys from all edge keys
+    for ( const auto& edgeKey : m_allEdgeKeys )
+    {
+        // If edge is already in the set, it occurs more than once and is not a boundary edge
+        // Assuming no degenerate triangles, i.e. triangle with two or more vertices at the same position
+        if ( edgeKeysAndCount.contains( edgeKey ) )
+        {
+            edgeKeysAndCount[edgeKey]++;
+        }
+        else
+        {
+            edgeKeysAndCount[edgeKey] = 1;
+        }
+    }
+
+    // At least a triangle is needed to construct a polygon
+    CVF_ASSERT( edgeKeysAndCount.size() >= 3 );
+
+    // Extract boundary edge keys from all edge keys and count
+    std::set<cvf::EdgeKey> boundaryEdges;
+    for ( const auto& [key, count] : edgeKeysAndCount )
+    {
+        if ( count == 1 )
+        {
+            boundaryEdges.insert( cvf::EdgeKey::fromkeyVal( key ) );
+        }
+    }
+
+    // Lambda function to check if index exists in a vector
+    auto indexExists = []( const std::vector<cvf::uint>& indices, cvf::uint index ) -> bool
+    { return std::find( indices.cbegin(), indices.cend(), index ) != indices.cend(); };
+
+    // Construct the enclosing polygon from the boundary edges
+    cvf::EdgeKey           currentEdge                   = *boundaryEdges.begin();
+    std::vector<cvf::uint> enclosingPolygonVertexIndices = { currentEdge.index1(), currentEdge.index2() };
+    cvf::uint              nextVertexIndex               = currentEdge.index2();
+    boundaryEdges.erase( currentEdge );
+    while ( !boundaryEdges.empty() )
+    {
+        // Find next edge in the boundary, i.e. edge containing the next vertex index to look for
+        currentEdge = findNextEdge( nextVertexIndex, boundaryEdges );
+        boundaryEdges.erase( currentEdge );
+        const auto start = currentEdge.index1();
+        const auto end   = currentEdge.index2();
+        if ( start == cvf::UNDEFINED_UINT || end == cvf::UNDEFINED_UINT )
+        {
+            // Throw error?
+            break;
+        }
+
+        // The enclosing polygon is a closed loop, so the start and end vertices are always in the correct order
+        if ( !indexExists( enclosingPolygonVertexIndices, end ) )
+        {
+            nextVertexIndex = end;
+            enclosingPolygonVertexIndices.push_back( end );
+        }
+        else if ( !indexExists( enclosingPolygonVertexIndices, start ) )
+        {
+            nextVertexIndex = start;
+            enclosingPolygonVertexIndices.push_back( start );
+        }
+    }
+
+    m_polygonVertexIndices = enclosingPolygonVertexIndices;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+cvf::EdgeKey RivEnclosingPolygonGenerator::findNextEdge( cvf::uint vertexIndex, const std::set<cvf::EdgeKey>& boundaryEdges )
+{
+    for ( auto& elm : boundaryEdges )
+    {
+        if ( elm.index1() == vertexIndex || elm.index2() == vertexIndex )
+        {
+            return elm;
+        }
+    }
+
+    // Return a dummy edge to indicate no next edge found
+    return cvf::EdgeKey( cvf::UNDEFINED_UINT, cvf::UNDEFINED_UINT );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<cvf::uint> RivEnclosingPolygonGenerator::getPolygonVertexIndices() const
+{
+    return m_polygonVertexIndices;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RivEnclosingPolygonGenerator::isValidPolygon() const
+{
+    return m_allEdgeKeys.size() >= size_t( 3 );
+}
+
+//--------------------------------------------------------------------------------------------------
+/// Add triangle vertices to the polygon. The vertex indices are welded and controlled outside
+/// of this class.
+///
+/// Assumes the vertices are given in counter-clockwise order
+//--------------------------------------------------------------------------------------------------
+void RivEnclosingPolygonGenerator::addTriangleVertexIndices( cvf::uint idxVx0, cvf::uint idxVx1, cvf::uint idxVx2 )
+{
+    // Verify three unique vertices - i.e. no degenerate triangle
+    if ( idxVx0 == idxVx1 || idxVx0 == idxVx2 || idxVx1 == idxVx2 )
+    {
+        return;
+    }
+
+    // Add edges keys to list of all edges
+    m_allEdgeKeys.emplace_back( cvf::EdgeKey( idxVx0, idxVx1 ).toKeyVal() );
+    m_allEdgeKeys.emplace_back( cvf::EdgeKey( idxVx1, idxVx2 ).toKeyVal() );
+    m_allEdgeKeys.emplace_back( cvf::EdgeKey( idxVx2, idxVx0 ).toKeyVal() );
+}

ApplicationLibCode/ModelVisualization/Intersections/RivEnclosingPolygonGenerator.h

@@ -0,0 +1,53 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2024-     Equinor ASA
+//
+//  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 "cvfBase.h"
+#include "cvfEdgeKey.h"
+
+#include <set>
+#include <vector>
+
+/*
+ * Class for generating an enclosing polygon from a set of vertices.
+ *
+ * The class add triangle vertex indices and construct constructing the enclosing polygon from the indices.
+ * The vertices must be provided in counter clock-wise order.
+ *
+ * The vertex welding, and mapping of vertex indices to vertex 3D points, must be handled externally.
+ */
+class RivEnclosingPolygonGenerator
+{
+public:
+    RivEnclosingPolygonGenerator();
+
+    std::vector<cvf::uint> getPolygonVertexIndices() const;
+
+    bool isValidPolygon() const;
+
+    void addTriangleVertexIndices( cvf::uint idxVx0, cvf::uint idxVx1, cvf::uint idxVx2 );
+    void constructEnclosingPolygon();
+
+private:
+    static cvf::EdgeKey findNextEdge( cvf::uint vertextIndex, const std::set<cvf::EdgeKey>& boundaryEdges );
+
+private:
+    std::vector<cvf::int64> m_allEdgeKeys; // Create edge defined by vertex indices when adding triangle. Using cvf::EdgeKey::toKeyVal()
+    std::vector<cvf::uint>  m_polygonVertexIndices; // List polygon vertex indices counter clock-wise
+};