OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Add helper class for polygon and 2D binary image operations

Browse Source
This commit is contained in:
Magne Sjaastad
2025-01-16 17:00:41 +01:00
parent 62bb40c4f4
commit 882e64f790
12 changed files with 609 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationLibCode/UnitTests/CMakeLists.txt
View File

@@ -106,6 +106,7 @@ set(SOURCE_UNITTEST_FILES
${CMAKE_CURRENT_LIST_DIR}/RifOsduWellPathReader-Test.cpp
${CMAKE_CURRENT_LIST_DIR}/RigVfpTables-Test.cpp
${CMAKE_CURRENT_LIST_DIR}/RiaResultName-Test.cpp
${CMAKE_CURRENT_LIST_DIR}/RigPolygonTools-Test.cpp
)
if(RESINSIGHT_ENABLE_GRPC)

173
ApplicationLibCode/UnitTests/RigPolygonTools-Test.cpp Normal file
View File

@@ -0,0 +1,173 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2020- 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 "RigPolygonTools.h"
#include "gtest/gtest.h"
// Test for erode function
TEST( RigPolygonToolsTest, ErodeTest )
{
// Arrange
RigPolygonTools::IntegerImage image = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } };
int kernelSize = 1;
RigPolygonTools::IntegerImage expected = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } };
// Act
RigPolygonTools::IntegerImage result = RigPolygonTools::erode( image, kernelSize );
// Assert
EXPECT_EQ( result, expected );
}
// Test for erode function with invalid input
TEST( RigPolygonToolsTest, ErodeInvalidInputTest )
{
// Arrange
RigPolygonTools::IntegerImage emptyImage = {};
int negativeKernelSize = -1;
// Act & Assert
EXPECT_EQ( emptyImage, RigPolygonTools::erode( emptyImage, 1 ) );
EXPECT_EQ( emptyImage, RigPolygonTools::erode( { { 1, 1 }, { 1 } }, 1 ) ); // Inconsistent row sizes
EXPECT_EQ( emptyImage, RigPolygonTools::erode( { { 1, 1 }, { 1, 1 } }, negativeKernelSize ) );
}
// Test for dilate function
TEST( RigPolygonToolsTest, DilateTest )
{
// Arrange
RigPolygonTools::IntegerImage image = {
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
};
int kernelSize = 2;
RigPolygonTools::IntegerImage expected = {
{ 0, 0, 0, 0, 0 },
{ 0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0 },
{ 0, 0, 0, 0, 0 },
};
// Act
RigPolygonTools::IntegerImage result = RigPolygonTools::dilate( image, kernelSize );
// Assert
EXPECT_EQ( result, expected );
}
// Test for dilate function with invalid input
TEST( RigPolygonToolsTest, DilateInvalidInputTest )
{
// Arrange
RigPolygonTools::IntegerImage emptyImage = {};
int negativeKernelSize = -1;
// Act & Assert
EXPECT_EQ( emptyImage, RigPolygonTools::dilate( emptyImage, 1 ) );
EXPECT_EQ( emptyImage, RigPolygonTools::dilate( { { 1, 1 }, { 1 } }, 1 ) ); // Inconsistent row sizes
EXPECT_EQ( emptyImage, RigPolygonTools::dilate( { { 1, 1 }, { 1, 1 } }, negativeKernelSize ) );
}
// Test for fillInterior function
TEST( RigPolygonToolsTest, FillInteriorTest )
{
// Arrange
RigPolygonTools::IntegerImage image = { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } };
RigPolygonTools::IntegerImage expected = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } };
// Act
RigPolygonTools::IntegerImage result = RigPolygonTools::fillInterior( image );
// Assert
EXPECT_EQ( result, expected );
}
// Test for fillInterior function with invalid input
TEST( RigPolygonToolsTest, FillInteriorInvalidInputTest )
{
// Arrange
RigPolygonTools::IntegerImage emptyImage = {};
// Act & Assert
EXPECT_EQ( emptyImage, RigPolygonTools::fillInterior( emptyImage ) );
EXPECT_EQ( emptyImage, RigPolygonTools::fillInterior( { { 1, 1 }, { 1 } } ) ); // Inconsistent row sizes
}
// Test for boundary function
TEST( RigPolygonToolsTest, BoundaryTest )
{
// Arrange
RigPolygonTools::IntegerImage image = { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 1, 1 } };
std::vector<std::pair<int, int>> expected = { { 0, 0 }, { 0, 1 }, { 0, 2 }, { 1, 2 }, { 2, 2 }, { 2, 1 }, { 2, 0 }, { 1, 0 } };
// Act
std::vector<std::pair<int, int>> result = RigPolygonTools::boundary( image );
// Assert
EXPECT_EQ( result, expected );
}
// Test for boundary function with invalid input
TEST( RigPolygonToolsTest, BoundaryInvalidInputTest )
{
// Arrange
RigPolygonTools::IntegerImage emptyImage = {};
// Act & Assert
EXPECT_TRUE( RigPolygonTools::boundary( emptyImage ).empty() );
EXPECT_TRUE( RigPolygonTools::boundary( { { 1, 1 }, { 1 } } ).empty() ); // Inconsistent row sizes
}
// Test for simplifyPolygon function
TEST( RigPolygonToolsTest, SimplifyPolygonTest )
{
// Arrange
std::vector<cvf::Vec3d> vertices =
{ { 0.0, 0.0, 0.0 }, { 1.0, 0.1, 0.0 }, { 1.5, -0.1, 0.0 }, { 3.0, 5.0, 0.0 }, { 5.0, 6.0, 0.0 }, { 7.0, 7.0, 0.0 }, { 8.0, 8.0, 0.0 } };
double epsilon = 1;
std::vector<cvf::Vec3d> expected = { { 0.0, 0.0, 0.0 }, { 1.5, -0.1, 0.0 }, { 3.0, 5.0, 0.0 }, { 8.0, 8.0, 0.0 } };
// Act
RigPolygonTools::simplifyPolygon( vertices, epsilon );
// Assert
EXPECT_EQ( vertices.size(), expected.size() );
for ( size_t i = 0; i < vertices.size(); ++i )
{
EXPECT_DOUBLE_EQ( vertices[i].x(), expected[i].x() );
EXPECT_DOUBLE_EQ( vertices[i].y(), expected[i].y() );
EXPECT_DOUBLE_EQ( vertices[i].z(), expected[i].z() );
}
}
// Test for simplifyPolygon function with invalid input
TEST( RigPolygonToolsTest, SimplifyPolygonInvalidInputTest )
{
// Arrange
std::vector<cvf::Vec3d> emptyVertices;
double epsilon = 1.0;
// Act & Assert
EXPECT_NO_THROW( RigPolygonTools::simplifyPolygon( emptyVertices, epsilon ) );
EXPECT_EQ( emptyVertices.size(), 0 );
}