potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-29 15:23:05 +04:00
Code Packages Releases Wiki Activity

Merge pull request #25382 from savuor:rv/fix_mesh_load

Browse Source 
Fix mesh loading for texture coordinates and face indices #25382

### This PR changes

* Texture coordinates were stored incorrectly (3-channel array is read as if there were 2 channels), fixed
* Faces were pushed back to the output array instead of indexed writing which produced a lot of empty faces, fixed
* A set of ground truth tests were added to cover these issues
* `std::vector<cv::Mat>` support added for `saveMesh()` which is required for Python bindings
* More command line args were added to rasterization test data generator

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
This commit is contained in:
Rostislav Vasilikhin
2024-04-16 09:20:44 +02:00
committed by GitHub
parent 3e561d8353
commit 6699ca1a40
6 changed files with 320 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/3d/test/test_pointcloud.cpp
+129 -52
View File
@@ -11,67 +11,135 @@
namespace opencv_test { namespace {
struct OriginalObjGoldValues
{
OriginalObjGoldValues()
{
std::array<float, 6> vals = { -5.93915f, -0.13257f, 2.55837f, 1.86743f, -1.16339f, 0.399941f };
points =
{
{ vals[0], vals[1], vals[2] },
{ vals[0], vals[3], vals[2] },
{ vals[0], vals[1], vals[4] },
{ vals[0], vals[3], vals[4] },
{ vals[5], vals[1], vals[2] },
{ vals[5], vals[3], vals[2] },
{ vals[5], vals[1], vals[4] },
{ vals[5], vals[3], vals[4] },
};
normals =
{
{-1.0f, 0.0f, 0.0f},
{ 0.0f, 0.0f, -1.0f},
{ 1.0f, 0.0f, 0.0f},
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, -1.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f}
};
rgb =
{
{0.0756f, 0.5651f, 0.5829f},
{0.8596f, 0.1105f, 0.8455f},
{0.8534f, 0.6143f, 0.3950f},
{0.0438f, 0.6308f, 0.3065f},
{0.9716f, 0.7170f, 0.8378f},
{0.2472f, 0.7701f, 0.0234f},
{0.6472f, 0.7467f, 0.5981f},
{0.3502f, 0.7954f, 0.0443f}
};
std::vector<std::pair<int, int>> tcvals =
{
{ 3, 0 },
{ 5, 0 },
{ 5, 2 },
{ 3, 2 },
{ 5, 4 },
{ 3, 4 },
{ 5, 6 },
{ 3, 6 },
{ 5, 8 },
{ 3, 8 },
{ 1, 4 },
{ 1, 6 },
{ 7, 4 },
{ 7, 6 },
};
for (const auto& p : tcvals)
{
texCoords.push_back({p.first * 0.125f, p.second * 0.125f});
}
// mesh data is duplicated for each face
std::vector<std::array<int, 9>> fileIndices =
{
{ 1, 1, 1, /**/ 2, 2, 1, /**/ 4, 3, 1 },
{ 3, 4, 2, /**/ 4, 3, 2, /**/ 8, 5, 2 },
{ 7, 6, 3, /**/ 8, 5, 3, /**/ 6, 7, 3 },
{ 5, 8, 4, /**/ 6, 7, 4, /**/ 2, 9, 4 },
{ 3, 11, 5, /**/ 7, 6, 5, /**/ 5, 8, 5 },
{ 8, 5, 6, /**/ 4, 13, 6, /**/ 2, 14, 6 },
};
for (const auto& fi : fileIndices)
{
pointsMesh.push_back(points.at(fi[0] - 1));
pointsMesh.push_back(points.at(fi[3] - 1));
pointsMesh.push_back(points.at(fi[6] - 1));
rgbMesh.push_back(rgb.at(fi[0] - 1));
rgbMesh.push_back(rgb.at(fi[3] - 1));
rgbMesh.push_back(rgb.at(fi[6] - 1));
texCoordsMesh.push_back(texCoords.at(fi[1] - 1));
texCoordsMesh.push_back(texCoords.at(fi[4] - 1));
texCoordsMesh.push_back(texCoords.at(fi[7] - 1));
normalsMesh.push_back(normals.at(fi[2] - 1));
normalsMesh.push_back(normals.at(fi[5] - 1));
normalsMesh.push_back(normals.at(fi[8] - 1));
}
indices =
{
{ 0, 1, 2},
{ 3, 4, 5},
{ 6, 7, 8},
{ 9, 10, 11},
{12, 13, 14},
{15, 16, 17},
};
}
std::vector<Point3f> points, pointsMesh, normals, normalsMesh, rgb, rgbMesh;
std::vector<Point2f> texCoords, texCoordsMesh;
std::vector<std::vector<int32_t>> indices;
};
OriginalObjGoldValues origGold;
TEST(PointCloud, LoadPointCloudObj)
{
std::vector<cv::Point3f> points_gold = {
{-5.93915f, -0.13257f, 2.55837f},
{-5.93915f, 1.86743f, 2.55837f},
{-5.93915f, -0.13257f, -1.16339f},
{-5.93915f, 1.86743f, -1.16339f},
{0.399941f, -0.13257f, 2.55837f},
{0.399941f, 1.86743f, 2.55837f},
{0.399941f, -0.13257f, -1.16339f},
{0.399941f, 1.86743f, -1.16339f}
};
std::vector<cv::Point3f> normals_gold = {
{-1.0000f, 0.0000f, 0.0000f},
{ 0.0000f, 0.0000f, -1.0000f},
{ 1.0000f, 0.0000f, 0.0000f},
{ 0.0000f, 0.0000f, 1.0000f},
{ 0.0000f, -1.0000f, 0.0000f},
{ 0.0000f, 1.0000f, 0.0000f}
};
std::vector<cv::Point3f> rgb_gold = {
{0.0756f, 0.5651f, 0.5829f},
{0.8596f, 0.1105f, 0.8455f},
{0.8534f, 0.6143f, 0.3950f},
{0.0438f, 0.6308f, 0.3065f},
{0.9716f, 0.7170f, 0.8378f},
{0.2472f, 0.7701f, 0.0234f},
{0.6472f, 0.7467f, 0.5981f},
{0.3502f, 0.7954f, 0.0443f}
};
std::vector<cv::Point3f> points, normals, rgb;
auto folder = cvtest::TS::ptr()->get_data_path();
cv::loadPointCloud(folder + "pointcloudio/orig.obj", points, normals, rgb);
EXPECT_EQ(points_gold, points);
EXPECT_EQ(rgb_gold, rgb);
EXPECT_EQ(normals_gold, normals);
EXPECT_EQ(origGold.points, points);
EXPECT_EQ(origGold.rgb, rgb);
EXPECT_EQ(origGold.normals, normals);
}
TEST(PointCloud, LoadObjNoNormals)
{
std::vector<cv::Point3f> points_gold = {
{-5.93915f, -0.13257f, 2.55837f},
{-5.93915f, 1.86743f, 2.55837f},
{-5.93915f, -0.13257f, -1.16339f},
{-5.93915f, 1.86743f, -1.16339f},
{0.399941f, -0.13257f, 2.55837f},
{0.399941f, 1.86743f, 2.55837f},
{0.399941f, -0.13257f, -1.16339f},
{0.399941f, 1.86743f, -1.16339f}};
std::vector<cv::Point3f> points, normals;
auto folder = cvtest::TS::ptr()->get_data_path();
cv::loadPointCloud(folder + "pointcloudio/orig_no_norms.obj", points, normals);
EXPECT_EQ(points_gold, points);
EXPECT_EQ(origGold.points, points);
EXPECT_TRUE(normals.empty());
}
@@ -125,11 +193,11 @@ TEST(PointCloud, LoadSaveMeshObj)
std::string new_path = tempfile("new_mesh.obj");
cv::loadMesh(folder + "pointcloudio/orig.obj", points, indices, normals, colors, texCoords);
EXPECT_FALSE(points.empty());
EXPECT_FALSE(indices.empty());
EXPECT_FALSE(normals.empty());
EXPECT_FALSE(colors.empty());
EXPECT_FALSE(texCoords.empty());
EXPECT_EQ(origGold.pointsMesh, points);
EXPECT_EQ(origGold.indices, indices);
EXPECT_EQ(origGold.normalsMesh, normals);
EXPECT_EQ(origGold.rgbMesh, colors);
EXPECT_EQ(origGold.texCoordsMesh, texCoords);
cv::saveMesh(new_path, points, indices, normals, colors, texCoords);
std::vector<cv::Point3f> points_gold, normals_gold, colors_gold;
@@ -164,8 +232,17 @@ TEST_P(PlyTest, LoadSaveMesh)
std::string new_path = tempfile("new_mesh.ply");
cv::loadMesh(folder + fname, points_gold, indices_gold, normals_gold, colors_gold);
EXPECT_FALSE(points_gold.empty());
EXPECT_FALSE(indices_gold.empty());
size_t truePts, trueFaces;
if (fname.find("/dragon.ply") != fname.npos)
{
truePts = 50000; trueFaces = 100000;
}
else
{
truePts = 8; trueFaces = 12;
}
EXPECT_EQ(points_gold.size(), truePts);
EXPECT_EQ(indices_gold.size(), trueFaces);
cv::saveMesh(new_path, points_gold, indices_gold, normals_gold, colors_gold);