FreeCAD

1
#include <gtest/gtest.h>
2
#include <Base/FileInfo.h>
3
#include <Base/Interpreter.h>
4
#include <App/Document.h>
5
#include <App/Part.h>
6
#include <src/App/InitApplication.h>
7
#include <Mod/Mesh/App/Exporter.h>
8
#include <Mod/Mesh/App/FeatureMeshSolid.h>
9
#include <Mod/Mesh/App/Mesh.h>
10

11
class ExporterTest: public ::testing::Test
12
{
13
protected:
14
    static void SetUpTestSuite()
15
    {
16
        tests::initApplication();
17
    }
18

19
    void SetUp() override
20
    {
21
        document = App::GetApplication().newDocument("MeshExport");
22
        fileInfo.setFile(Base::FileInfo::getTempFileName() + ".stl");
23

24
        const double value = 10.0;
25
        cube1 = dynamic_cast<Mesh::Cube*>(document->addObject("Mesh::Cube", "Cube1"));
26
        cube1->Length.setValue(value);
27
        cube1->Width.setValue(value);
28
        cube1->Height.setValue(value);
29
        cube2 = dynamic_cast<Mesh::Cube*>(document->addObject("Mesh::Cube", "Cube2"));
30
        cube2->Length.setValue(value);
31
        cube2->Width.setValue(value);
32
        cube2->Height.setValue(value);
33

34
        document->recompute();
35
    }
36

37
    void TearDown() override
38
    {
39
        App::GetApplication().closeDocument(document->getName());
40
        fileInfo.deleteFile();
41
    }
42

43
    App::Document* getDocument() const
44
    {
45
        return document;
46
    }
47

48
    std::vector<App::DocumentObject*> getObjects() const
49
    {
50
        return {cube1, cube2};
51
    }
52

53
    App::DocumentObject* getMesh2() const
54
    {
55
        return cube2;
56
    }
57

58
    void setPlacementTo2ndCube(const Base::Placement& plm)
59
    {
60
        cube2->Placement.setValue(plm);
61
    }
62

63
    std::string getFileName() const
64
    {
65
        return fileInfo.filePath();
66
    }
67

68
private:
69
    Base::FileInfo fileInfo;
70
    App::Document* document {};
71
    Mesh::Cube* cube1 {};
72
    Mesh::Cube* cube2 {};
73
};
74

75
// NOLINTBEGIN(cppcoreguidelines-*,readability-*)
76
TEST_F(ExporterTest, TestSingleMesh)
77
{
78
    Base::Placement plm;
79
    plm.setPosition(Base::Vector3d(10, 5, 2));
80
    setPlacementTo2ndCube(plm);
81

82
    // add extra scope because the file will be written when destroying the exporter
83
    {
84
        Mesh::MergeExporter exporter(getFileName(), MeshCore::MeshIO::Format::STL);
85
        exporter.addObject(getMesh2(), 0.1F);
86
    }
87

88
    Mesh::MeshObject kernel;
89
    EXPECT_TRUE(kernel.load(getFileName().c_str()));
90
    auto bbox = kernel.getBoundBox();
91
    EXPECT_DOUBLE_EQ(bbox.MinX, 5.0);
92
    EXPECT_DOUBLE_EQ(bbox.MaxX, 15.0);
93
    EXPECT_DOUBLE_EQ(bbox.MinY, 0.0);
94
    EXPECT_DOUBLE_EQ(bbox.MaxY, 10.0);
95
    EXPECT_DOUBLE_EQ(bbox.MinZ, -3.0);
96
    EXPECT_DOUBLE_EQ(bbox.MaxZ, 7.0);
97
}
98

99
// Test for https://github.com/FreeCAD/FreeCAD/pull/11539
100
TEST_F(ExporterTest, TestMultipleMeshes)
101
{
102
    Base::Placement plm;
103
    plm.setPosition(Base::Vector3d(10, 5, 2));
104
    setPlacementTo2ndCube(plm);
105

106
    // add extra scope because the file will be written when destroying the exporter
107
    {
108
        Mesh::MergeExporter exporter(getFileName(), MeshCore::MeshIO::Format::STL);
109
        for (auto obj : getObjects()) {
110
            exporter.addObject(obj, 0.1F);
111
        }
112
    }
113

114
    Mesh::MeshObject kernel;
115
    EXPECT_TRUE(kernel.load(getFileName().c_str()));
116
    auto bbox = kernel.getBoundBox();
117
    EXPECT_DOUBLE_EQ(bbox.MinX, -5.0);
118
    EXPECT_DOUBLE_EQ(bbox.MaxX, 15.0);
119
    EXPECT_DOUBLE_EQ(bbox.MinY, -5.0);
120
    EXPECT_DOUBLE_EQ(bbox.MaxY, 10.0);
121
    EXPECT_DOUBLE_EQ(bbox.MinZ, -5.0);
122
    EXPECT_DOUBLE_EQ(bbox.MaxZ, 7.0);
123
}
124

125
TEST_F(ExporterTest, TestMeshesInPart)
126
{
127
    Base::Placement plm;
128
    plm.setPosition(Base::Vector3d(10, 5, 2));
129
    setPlacementTo2ndCube(plm);
130

131
    // add extra scope because the file will be written when destroying the exporter
132
    {
133
        auto part = dynamic_cast<App::Part*>(getDocument()->addObject("App::Part", "Part"));
134
        part->placement().setValue(plm);
135
        part->addObjects(getObjects());
136
        Mesh::MergeExporter exporter(getFileName(), MeshCore::MeshIO::Format::STL);
137
        exporter.addObject(part, 0.1F);
138
    }
139

140
    Mesh::MeshObject kernel;
141
    EXPECT_TRUE(kernel.load(getFileName().c_str()));
142
    auto bbox = kernel.getBoundBox();
143
    EXPECT_DOUBLE_EQ(bbox.MinX, 5.0);
144
    EXPECT_DOUBLE_EQ(bbox.MaxX, 25.0);
145
    EXPECT_DOUBLE_EQ(bbox.MinY, 0.0);
146
    EXPECT_DOUBLE_EQ(bbox.MaxY, 15.0);
147
    EXPECT_DOUBLE_EQ(bbox.MinZ, -3.0);
148
    EXPECT_DOUBLE_EQ(bbox.MaxZ, 9.0);
149
}
150
// NOLINTEND(cppcoreguidelines-*,readability-*)
151