#4549 Add python method to get cell corners on a grid

Equivalent to GetCellCorners in Octave.

ApplicationCode/GrpcInterface/GrpcProtos/Definitions.proto

@@ -28,3 +28,19 @@ message CellCenters
 {
 	repeated Vec3d centers = 1;
 }
+
+message CellCorners {
+        Vec3d c0 = 1;
+        Vec3d c1 = 2;
+        Vec3d c2 = 3;
+        Vec3d c3 = 4;
+        Vec3d c4 = 5;
+        Vec3d c5 = 6;
+        Vec3d c6 = 7;
+        Vec3d c7 = 8;
+}
+
+message CellCornersArray
+{
+	repeated CellCorners cells = 1;
+}

ApplicationCode/GrpcInterface/GrpcProtos/Grid.proto

@@ -8,6 +8,7 @@ import "Case.proto";
 service Grid
 {
 	rpc GetCellCenters(GridRequest) returns(stream CellCenters) {}
+	rpc GetCellCorners(GridRequest) returns(stream CellCornersArray) {}
 	rpc GetDimensions(GridRequest) returns (GridDimensions) {}
 }
 

ApplicationCode/GrpcInterface/Python/rips/grid.py

@@ -59,3 +59,30 @@ class Grid:
             for center in chunk.centers:
                 centers.append(center)
         return centers
+
+    def cell_corners_async(self):
+        """The cell corners for all cells in given grid, async.
+
+        Returns:
+            iterator to a list of CellCorners: a class with Vec3d for each corner (c0, c1.., c7)
+        """
+        case_request = Case_pb2.CaseRequest(id=self.case.case_id)
+        chunks = self.__stub.GetCellCorners(
+            Grid_pb2.GridRequest(case_request=case_request,
+                                 grid_index=self.index))
+
+        for chunk in chunks:
+            yield chunk
+
+    def cell_corners(self):
+        """The cell corners for all cells in given grid
+
+        Returns:
+            list of CellCorners: a class with Vec3d for each corner (c0, c1.., c7)
+        """
+        corners = []
+        chunks = self.cell_corners_async()
+        for chunk in chunks:
+            for center in chunk.cells:
+                corners.append(center)
+        return corners

ApplicationCode/GrpcInterface/Python/rips/tests/test_grids.py

@@ -1,11 +1,17 @@
 import sys
 import os
+import math
 
 sys.path.insert(1, os.path.join(sys.path[0], '../../'))
 import rips
 
 import dataroot
 
+def check_corner(actual, expected):
+    assert(math.isclose(actual.x, expected[0], abs_tol=0.1))
+    assert(math.isclose(actual.y, expected[1], abs_tol=0.1))
+    assert(math.isclose(actual.z, expected[2], abs_tol=0.1))
+
 def test_10k(rips_instance, initialize_test):
     casePath = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
     case = rips_instance.project.load_case(path=casePath)
@@ -18,3 +24,30 @@ def test_10k(rips_instance, initialize_test):
 
     cell_centers = grid.cell_centers()
     assert(len(cell_centers) == (dimensions.i * dimensions.j * dimensions.k))
+
+    # Test a specific cell (results from ResInsight UI)
+    cell_index = 168143
+    assert(math.isclose(3627.17, cell_centers[cell_index].x, abs_tol=0.1))
+    assert(math.isclose(5209.75, cell_centers[cell_index].y, abs_tol=0.1))
+    assert(math.isclose(4179.6, cell_centers[cell_index].z, abs_tol=0.1))
+
+    cell_corners = grid.cell_corners()
+    assert(len(cell_corners) == (dimensions.i * dimensions.j * dimensions.k))
+
+    # Expected values from ResInsight UI
+    expected_corners = [[ 3565.22, 5179.02, 4177.18],
+                        [ 3655.67, 5145.34, 4176.63],
+                        [ 3690.07, 5240.69, 4180.02],
+                        [ 3599.87, 5275.16, 4179.32],
+                        [ 3564.13, 5178.61, 4179.75],
+                        [ 3654.78, 5144.79, 4179.23],
+                        [ 3688.99, 5239.88, 4182.7],
+                        [ 3598.62, 5274.48, 4181.96]]
+    check_corner(cell_corners[cell_index].c0, expected_corners[0])
+    check_corner(cell_corners[cell_index].c1, expected_corners[1])
+    check_corner(cell_corners[cell_index].c2, expected_corners[2])
+    check_corner(cell_corners[cell_index].c3, expected_corners[3])
+    check_corner(cell_corners[cell_index].c4, expected_corners[4])
+    check_corner(cell_corners[cell_index].c5, expected_corners[5])
+    check_corner(cell_corners[cell_index].c6, expected_corners[6])
+    check_corner(cell_corners[cell_index].c7, expected_corners[7])

ApplicationCode/GrpcInterface/RiaGrpcGridService.cpp

@@ -101,6 +101,50 @@ grpc::Status RiaCellCenterStateHandler::assignReply( rips::CellCenters* reply )
     return Status( grpc::OUT_OF_RANGE, "We've reached the end. This is not an error but means transmission is finished" );
 }
 
+void setCornerValues( rips::Vec3d* out, const cvf::Vec3d& in )
+{
+    out->set_x( in.x() );
+    out->set_y( in.y() );
+    out->set_z( in.z() );
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+grpc::Status RiaCellCenterStateHandler::assignCornersReply( rips::CellCornersArray* reply )
+{
+    const size_t packageSize = RiaGrpcServiceInterface::numberOfMessagesForByteCount( sizeof( rips::CellCornersArray ) );
+    size_t       packageIndex = 0u;
+    reply->mutable_cells()->Reserve( (int)packageSize );
+
+    cvf::Vec3d cornerVerts[8];
+    for ( ; packageIndex < packageSize && m_currentCellIdx < m_grid->cellCount(); ++packageIndex )
+    {
+        m_grid->cellCornerVertices( m_currentCellIdx, cornerVerts );
+        for ( cvf::Vec3d& corner : cornerVerts )
+        {
+            convertVec3dToPositiveDepth( &corner );
+        }
+
+        rips::CellCorners* corners = reply->add_cells();
+        setCornerValues( corners->mutable_c0(), cornerVerts[0] );
+        setCornerValues( corners->mutable_c1(), cornerVerts[1] );
+        setCornerValues( corners->mutable_c2(), cornerVerts[2] );
+        setCornerValues( corners->mutable_c3(), cornerVerts[3] );
+        setCornerValues( corners->mutable_c4(), cornerVerts[4] );
+        setCornerValues( corners->mutable_c5(), cornerVerts[5] );
+        setCornerValues( corners->mutable_c6(), cornerVerts[6] );
+        setCornerValues( corners->mutable_c7(), cornerVerts[7] );
+
+        m_currentCellIdx++;
+    }
+    if ( packageIndex > 0u )
+    {
+        return Status::OK;
+    }
+    return Status( grpc::OUT_OF_RANGE, "We've reached the end. This is not an error but means transmission is finished" );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -142,6 +186,17 @@ grpc::Status RiaGrpcGridService::GetCellCenters( grpc::ServerContext*       cont
     return stateHandler->assignReply( reply );
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+grpc::Status RiaGrpcGridService::GetCellCorners( grpc::ServerContext*       context,
+                                                 const rips::GridRequest*   request,
+                                                 rips::CellCornersArray*    reply,
+                                                 RiaCellCenterStateHandler* stateHandler )
+{
+    return stateHandler->assignCornersReply( reply );
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -156,6 +211,11 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcGridService::createCallbacks()
                                                                                                             &Self::RequestGetCellCenters,
                                                                                                             new RiaCellCenterStateHandler ),
 
+        new RiaGrpcServerToClientStreamCallback<Self, GridRequest, CellCornersArray, RiaCellCenterStateHandler>( this,
+                                                                                                                 &Self::GetCellCorners,
+                                                                                                                 &Self::RequestGetCellCorners,
+                                                                                                                 new RiaCellCenterStateHandler ),
+
         new RiaGrpcUnaryCallback<Self, GridRequest, GridDimensions>( this, &Self::GetDimensions, &Self::RequestGetDimensions )};
 }
 

ApplicationCode/GrpcInterface/RiaGrpcGridService.h

@@ -46,6 +46,7 @@ public:
     RiaCellCenterStateHandler();
     grpc::Status init( const rips::GridRequest* request );
     grpc::Status assignReply( rips::CellCenters* reply );
+    grpc::Status assignCornersReply( rips::CellCornersArray* reply );
 
 protected:
     const rips::GridRequest* m_request;
@@ -62,6 +63,11 @@ public:
                                  rips::CellCenters*         reply,
                                  RiaCellCenterStateHandler* stateHandler );
 
+    grpc::Status GetCellCorners( grpc::ServerContext*       context,
+                                 const rips::GridRequest*   request,
+                                 rips::CellCornersArray*    reply,
+                                 RiaCellCenterStateHandler* stateHandler );
+
     grpc::Status GetDimensions( grpc::ServerContext*     context,
                                 const rips::GridRequest* request,
                                 rips::GridDimensions*    reply ) override;