132 lines
5.1 KiB
C++
132 lines
5.1 KiB
C++
#include <catch2/catch.hpp>
|
|
|
|
#include "libslic3r/Model.hpp"
|
|
#include "libslic3r/Format/3mf.hpp"
|
|
#include "libslic3r/Format/STL.hpp"
|
|
|
|
#include <boost/filesystem/operations.hpp>
|
|
|
|
using namespace Slic3r;
|
|
|
|
SCENARIO("Reading 3mf file", "[3mf]") {
|
|
GIVEN("umlauts in the path of the file") {
|
|
Model model;
|
|
WHEN("3mf model is read") {
|
|
std::string path = std::string(TEST_DATA_DIR) + "/test_3mf/Geräte/Büchse.3mf";
|
|
DynamicPrintConfig config;
|
|
bool ret = load_3mf(path.c_str(), &config, &model, false);
|
|
THEN("load should succeed") {
|
|
REQUIRE(ret);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("Export+Import geometry to/from 3mf file cycle", "[3mf]") {
|
|
GIVEN("world vertices coordinates before save") {
|
|
// load a model from stl file
|
|
Model src_model;
|
|
std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
|
|
load_stl(src_file.c_str(), &src_model);
|
|
src_model.add_default_instances();
|
|
|
|
ModelObject* src_object = src_model.objects.front();
|
|
|
|
// apply generic transformation to the 1st volume
|
|
Geometry::Transformation src_volume_transform;
|
|
src_volume_transform.set_offset({ 10.0, 20.0, 0.0 });
|
|
src_volume_transform.set_rotation({ Geometry::deg2rad(25.0), Geometry::deg2rad(35.0), Geometry::deg2rad(45.0) });
|
|
src_volume_transform.set_scaling_factor({ 1.1, 1.2, 1.3 });
|
|
src_volume_transform.set_mirror({ -1.0, 1.0, -1.0 });
|
|
src_object->volumes.front()->set_transformation(src_volume_transform);
|
|
|
|
// apply generic transformation to the 1st instance
|
|
Geometry::Transformation src_instance_transform;
|
|
src_instance_transform.set_offset({ 5.0, 10.0, 0.0 });
|
|
src_instance_transform.set_rotation({ Geometry::deg2rad(12.0), Geometry::deg2rad(13.0), Geometry::deg2rad(14.0) });
|
|
src_instance_transform.set_scaling_factor({ 0.9, 0.8, 0.7 });
|
|
src_instance_transform.set_mirror({ 1.0, -1.0, -1.0 });
|
|
src_object->instances.front()->set_transformation(src_instance_transform);
|
|
|
|
WHEN("model is saved+loaded to/from 3mf file") {
|
|
// save the model to 3mf file
|
|
std::string test_file = std::string(TEST_DATA_DIR) + "/test_3mf/prusa.3mf";
|
|
store_3mf(test_file.c_str(), &src_model, nullptr, false);
|
|
|
|
// load back the model from the 3mf file
|
|
Model dst_model;
|
|
DynamicPrintConfig dst_config;
|
|
load_3mf(test_file.c_str(), &dst_config, &dst_model, false);
|
|
boost::filesystem::remove(test_file);
|
|
|
|
// compare meshes
|
|
TriangleMesh src_mesh = src_model.mesh();
|
|
src_mesh.repair();
|
|
|
|
TriangleMesh dst_mesh = dst_model.mesh();
|
|
dst_mesh.repair();
|
|
|
|
bool res = src_mesh.its.vertices.size() == dst_mesh.its.vertices.size();
|
|
if (res) {
|
|
for (size_t i = 0; i < dst_mesh.its.vertices.size(); ++i) {
|
|
res &= dst_mesh.its.vertices[i].isApprox(src_mesh.its.vertices[i]);
|
|
}
|
|
}
|
|
THEN("world vertices coordinates after load match") {
|
|
REQUIRE(res);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SCENARIO("2D convex hull of sinking object", "[3mf]") {
|
|
GIVEN("model") {
|
|
// load a model
|
|
Model model;
|
|
std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
|
|
load_stl(src_file.c_str(), &model);
|
|
model.add_default_instances();
|
|
|
|
WHEN("model is rotated, scaled and set as sinking") {
|
|
ModelObject* object = model.objects.front();
|
|
object->center_around_origin(false);
|
|
|
|
// set instance's attitude so that it is rotated, scaled and sinking
|
|
ModelInstance* instance = object->instances.front();
|
|
instance->set_rotation(Y, -M_PI / 4.0);
|
|
instance->set_offset(Vec3d::Zero());
|
|
instance->set_scaling_factor({ 2.0, 2.0, 2.0 });
|
|
|
|
// calculate 2D convex hull
|
|
Polygon hull_2d = object->convex_hull_2d(instance->get_transformation().get_matrix());
|
|
|
|
// verify result
|
|
Points result = {
|
|
{ -4242641, -16299551 },
|
|
{ -4241, -19502998 },
|
|
{ 66824768, -19502998 },
|
|
{ 66824768, 19502998 },
|
|
{ -4244, 19502998 },
|
|
{ -4242640, -8537523 }
|
|
};
|
|
|
|
bool res = hull_2d.points.size() == result.size();
|
|
if (res) {
|
|
for (size_t i = 0; i < result.size(); ++i) {
|
|
Vec3d hull_p(unscale<double>(hull_2d.points[i].x()), unscale<double>(hull_2d.points[i].y()), 0.0);
|
|
Vec3d res_p(unscale<double>(result[i].x()), unscale<double>(result[i].y()), 0.0);
|
|
res &= res_p.isApprox(hull_p);
|
|
}
|
|
}
|
|
|
|
// this does not work on RaspberryPi for float precision problem: the x of 1st vertex ending up being -4242640 instead of -4242641
|
|
// bool res = hull_2d.points == result;
|
|
|
|
THEN("2D convex hull should match with reference") {
|
|
REQUIRE(res);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|