FreeCAD

1
/***************************************************************************
2
 *   Copyright (c) 2013 Werner Mayer <wmayer[at]users.sourceforge.net>     *
3
 *                                                                         *
4
 *   This file is part of the FreeCAD CAx development system.              *
5
 *                                                                         *
6
 *   This library is free software; you can redistribute it and/or         *
7
 *   modify it under the terms of the GNU Library General Public           *
8
 *   License as published by the Free Software Foundation; either          *
9
 *   version 2 of the License, or (at your option) any later version.      *
10
 *                                                                         *
11
 *   This library  is distributed in the hope that it will be useful,      *
12
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14
 *   GNU Library General Public License for more details.                  *
15
 *                                                                         *
16
 *   You should have received a copy of the GNU Library General Public     *
17
 *   License along with this library; see the file COPYING.LIB. If not,    *
18
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
19
 *   Suite 330, Boston, MA  02111-1307, USA                                *
20
 *                                                                         *
21
 ***************************************************************************/
22

23
#include "PreCompiled.h"
24

25
#include "Decimation.h"
26
#include "MeshKernel.h"
27
#include "Simplify.h"
28

29

30
using namespace MeshCore;
31

32
MeshSimplify::MeshSimplify(MeshKernel& mesh)
33
    : myKernel(mesh)
34
{}
35

36
void MeshSimplify::simplify(float tolerance, float reduction)
37
{
38
    Simplify alg;
39

40
    const MeshPointArray& points = myKernel.GetPoints();
41
    for (std::size_t i = 0; i < points.size(); i++) {
42
        Simplify::Vertex v;
43
        v.tstart = 0;
44
        v.tcount = 0;
45
        v.border = 0;
46
        v.p = points[i];
47
        alg.vertices.push_back(v);
48
    }
49

50
    const MeshFacetArray& facets = myKernel.GetFacets();
51
    for (std::size_t i = 0; i < facets.size(); i++) {
52
        Simplify::Triangle t;
53
        t.deleted = 0;
54
        t.dirty = 0;
55
        for (double& j : t.err) {
56
            j = 0.0;
57
        }
58
        for (int j = 0; j < 3; j++) {
59
            t.v[j] = facets[i]._aulPoints[j];
60
        }
61
        alg.triangles.push_back(t);
62
    }
63

64
    int target_count = static_cast<int>(static_cast<float>(facets.size()) * (1.0f - reduction));
65

66
    // Simplification starts
67
    alg.simplify_mesh(target_count, tolerance);
68

69
    // Simplification done
70
    MeshPointArray new_points;
71
    new_points.reserve(alg.vertices.size());
72
    for (const auto& vertex : alg.vertices) {
73
        new_points.push_back(vertex.p);
74
    }
75

76
    std::size_t numFacets = 0;
77
    for (const auto& triangle : alg.triangles) {
78
        if (!triangle.deleted) {
79
            numFacets++;
80
        }
81
    }
82
    MeshFacetArray new_facets;
83
    new_facets.reserve(numFacets);
84
    for (const auto& triangle : alg.triangles) {
85
        if (!triangle.deleted) {
86
            MeshFacet face;
87
            face._aulPoints[0] = triangle.v[0];
88
            face._aulPoints[1] = triangle.v[1];
89
            face._aulPoints[2] = triangle.v[2];
90
            new_facets.push_back(face);
91
        }
92
    }
93

94
    myKernel.Adopt(new_points, new_facets, true);
95
}
96

97
void MeshSimplify::simplify(int targetSize)
98
{
99
    Simplify alg;
100

101
    const MeshPointArray& points = myKernel.GetPoints();
102
    for (std::size_t i = 0; i < points.size(); i++) {
103
        Simplify::Vertex v;
104
        v.tstart = 0;
105
        v.tcount = 0;
106
        v.border = 0;
107
        v.p = points[i];
108
        alg.vertices.push_back(v);
109
    }
110

111
    const MeshFacetArray& facets = myKernel.GetFacets();
112
    for (std::size_t i = 0; i < facets.size(); i++) {
113
        Simplify::Triangle t;
114
        t.deleted = 0;
115
        t.dirty = 0;
116
        for (double& j : t.err) {
117
            j = 0.0;
118
        }
119
        for (int j = 0; j < 3; j++) {
120
            t.v[j] = facets[i]._aulPoints[j];
121
        }
122
        alg.triangles.push_back(t);
123
    }
124

125
    // Simplification starts
126
    alg.simplify_mesh(targetSize, FLT_MAX);
127

128
    // Simplification done
129
    MeshPointArray new_points;
130
    new_points.reserve(alg.vertices.size());
131
    for (const auto& vertex : alg.vertices) {
132
        new_points.push_back(vertex.p);
133
    }
134

135
    std::size_t numFacets = 0;
136
    for (const auto& triangle : alg.triangles) {
137
        if (!triangle.deleted) {
138
            numFacets++;
139
        }
140
    }
141
    MeshFacetArray new_facets;
142
    new_facets.reserve(numFacets);
143
    for (const auto& triangle : alg.triangles) {
144
        if (!triangle.deleted) {
145
            MeshFacet face;
146
            face._aulPoints[0] = triangle.v[0];
147
            face._aulPoints[1] = triangle.v[1];
148
            face._aulPoints[2] = triangle.v[2];
149
            new_facets.push_back(face);
150
        }
151
    }
152

153
    myKernel.Adopt(new_points, new_facets, true);
154
}
155