mirror of
https://github.com/opencv/opencv.git
synced 2024-12-15 09:49:13 +08:00
6699ca1a40
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
300 lines
9.1 KiB
C++
300 lines
9.1 KiB
C++
// This file is part of OpenCV project.
|
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
|
// of this distribution and at http://opencv.org/license.html.
|
|
|
|
#include <opencv2/core.hpp>
|
|
#include <vector>
|
|
#include <cstdio>
|
|
|
|
#include "test_precomp.hpp"
|
|
#include "opencv2/ts.hpp"
|
|
|
|
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, normals, rgb;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
cv::loadPointCloud(folder + "pointcloudio/orig.obj", points, normals, rgb);
|
|
|
|
EXPECT_EQ(origGold.points, points);
|
|
EXPECT_EQ(origGold.rgb, rgb);
|
|
EXPECT_EQ(origGold.normals, normals);
|
|
}
|
|
|
|
TEST(PointCloud, LoadObjNoNormals)
|
|
{
|
|
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(origGold.points, points);
|
|
EXPECT_TRUE(normals.empty());
|
|
}
|
|
|
|
TEST(PointCloud, SaveObj)
|
|
{
|
|
std::vector<cv::Point3f> points_gold, normals_gold, rgb_gold;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
auto new_path = tempfile("new.obj");
|
|
|
|
cv::loadPointCloud(folder + "pointcloudio/orig.obj", points_gold, normals_gold, rgb_gold);
|
|
cv::savePointCloud(new_path, points_gold, normals_gold, rgb_gold);
|
|
|
|
std::vector<cv::Point3f> points, normals, rgb;
|
|
|
|
cv::loadPointCloud(new_path, points, normals, rgb);
|
|
|
|
EXPECT_EQ(normals, normals_gold);
|
|
EXPECT_EQ(points, points_gold);
|
|
EXPECT_EQ(rgb, rgb_gold);
|
|
std::remove(new_path.c_str());
|
|
}
|
|
|
|
TEST(PointCloud, LoadSavePly)
|
|
{
|
|
std::vector<cv::Point3f> points, normals, rgb;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
std::string new_path = tempfile("new.ply");
|
|
|
|
cv::loadPointCloud(folder + "pointcloudio/orig.ply", points, normals, rgb);
|
|
cv::savePointCloud(new_path, points, normals, rgb);
|
|
|
|
std::vector<cv::Point3f> points_gold, normals_gold, rgb_gold;
|
|
|
|
cv::loadPointCloud(new_path, points_gold, normals_gold, rgb_gold);
|
|
|
|
EXPECT_EQ(normals_gold, normals);
|
|
EXPECT_EQ(points_gold, points);
|
|
EXPECT_EQ(rgb_gold, rgb);
|
|
std::remove(new_path.c_str());
|
|
}
|
|
|
|
TEST(PointCloud, LoadSaveMeshObj)
|
|
{
|
|
std::vector<cv::Point3f> points, normals, colors;
|
|
std::vector<cv::Point2f> texCoords;
|
|
std::vector<std::vector<int32_t>> indices;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
std::string new_path = tempfile("new_mesh.obj");
|
|
|
|
cv::loadMesh(folder + "pointcloudio/orig.obj", points, indices, normals, colors, texCoords);
|
|
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;
|
|
std::vector<cv::Point2f> texCoords_gold;
|
|
std::vector<std::vector<int32_t>> indices_gold;
|
|
|
|
cv::loadMesh(new_path, points_gold, indices_gold, normals_gold, colors_gold, texCoords_gold);
|
|
EXPECT_FALSE(points_gold.empty());
|
|
EXPECT_FALSE(indices_gold.empty());
|
|
EXPECT_FALSE(normals_gold.empty());
|
|
EXPECT_FALSE(colors_gold.empty());
|
|
EXPECT_FALSE(texCoords_gold.empty());
|
|
|
|
EXPECT_EQ(normals_gold, normals);
|
|
EXPECT_EQ(points_gold, points);
|
|
EXPECT_EQ(indices_gold, indices);
|
|
EXPECT_TRUE(!indices.empty());
|
|
std::remove(new_path.c_str());
|
|
}
|
|
|
|
typedef std::string PlyTestParamsType;
|
|
typedef testing::TestWithParam<PlyTestParamsType> PlyTest;
|
|
|
|
TEST_P(PlyTest, LoadSaveMesh)
|
|
{
|
|
std::string fname = GetParam();
|
|
|
|
std::vector<cv::Point3f> points_gold, normals_gold, colors_gold;
|
|
std::vector<cv::Vec3i> indices_gold;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
std::string new_path = tempfile("new_mesh.ply");
|
|
|
|
cv::loadMesh(folder + fname, points_gold, indices_gold, normals_gold, colors_gold);
|
|
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);
|
|
|
|
std::vector<cv::Point3f> points, normals, colors;
|
|
std::vector<cv::Vec3i> indices;
|
|
cv::loadMesh(new_path, points, indices, normals, colors);
|
|
|
|
if (!normals.empty())
|
|
{
|
|
EXPECT_LE(cv::norm(normals_gold, normals, NORM_INF), 0);
|
|
}
|
|
EXPECT_LE(cv::norm(points_gold, points, NORM_INF), 0);
|
|
EXPECT_LE(cv::norm(colors_gold, colors, NORM_INF), 0);
|
|
EXPECT_EQ(indices_gold, indices);
|
|
std::remove(new_path.c_str());
|
|
}
|
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(PointCloud, PlyTest,
|
|
::testing::Values("pointcloudio/orig.ply", "pointcloudio/orig_ascii_fidx.ply", "pointcloudio/orig_bin_fidx.ply",
|
|
"pointcloudio/orig_ascii_vidx.ply", "pointcloudio/orig_bin.ply", "viz/dragon.ply"));
|
|
|
|
TEST(PointCloud, NonexistentFile)
|
|
{
|
|
std::vector<cv::Point3f> points;
|
|
std::vector<cv::Point3f> normals;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
cv::loadPointCloud(folder + "pointcloudio/fake.obj", points, normals);
|
|
EXPECT_TRUE(points.empty());
|
|
EXPECT_TRUE(normals.empty());
|
|
}
|
|
|
|
TEST(PointCloud, LoadBadExtension)
|
|
{
|
|
std::vector<cv::Point3f> points;
|
|
std::vector<cv::Point3f> normals;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
cv::loadPointCloud(folder + "pointcloudio/fake.fake", points, normals);
|
|
EXPECT_TRUE(points.empty());
|
|
EXPECT_TRUE(normals.empty());
|
|
}
|
|
|
|
TEST(PointCloud, SaveBadExtension)
|
|
{
|
|
std::vector<cv::Point3f> points;
|
|
std::vector<cv::Point3f> normals;
|
|
|
|
auto folder = cvtest::TS::ptr()->get_data_path();
|
|
cv::savePointCloud(folder + "pointcloudio/fake.fake", points, normals);
|
|
}
|
|
|
|
}} /* namespace opencv_test */
|