1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// Begin License:
// Copyright (C) 2006-2014 Tobias Sargeant (tobias.sargeant@gmail.com).
// All rights reserved.
//
// This file is part of the Carve CSG Library (http://carve-csg.com/)
//
// This file may be used under the terms of either the GNU General
// Public License version 2 or 3 (at your option) as published by the
// Free Software Foundation and appearing in the files LICENSE.GPL2
// and LICENSE.GPL3 included in the packaging of this file.
//
// This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
// INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE.
// End:
#pragma once
#include <carve/carve.hpp>
#include <carve/geom3d.hpp>
#include <carve/polyhedron_base.hpp>
#include <carve/octree_decl.hpp>
#include <carve/collection_types.hpp>
#include <assert.h>
#include <list>
namespace carve {
namespace mesh {
template<unsigned ndim>
class MeshSet;
}
namespace poly {
class Polyhedron;
}
poly::Polyhedron *polyhedronFromMesh(const mesh::MeshSet<3> *, int);
namespace poly {
class Polyhedron : public Geometry<3> {
private:
friend Polyhedron *carve::polyhedronFromMesh(const mesh::MeshSet<3> *, int);
Polyhedron() {
}
Polyhedron &operator=(const Polyhedron &); // not implemented
// *** initialization
bool initSpatialIndex();
void initVertexConnectivity();
void setFaceAndVertexOwner();
bool initConnectivity();
bool markManifolds();
bool calcManifoldEmbedding();
bool init();
void faceRecalc();
void commonFaceInit(bool _recalc);
public:
static void collectFaceVertices(std::vector<face_t > &faces,
std::vector<vertex_t > &vertices,
std::unordered_map<const vertex_t *, const vertex_t *> &vmap);
static void collectFaceVertices(std::vector<face_t > &faces,
std::vector<vertex_t > &vertices);
std::vector<bool> manifold_is_closed;
std::vector<bool> manifold_is_negative;
carve::geom3d::AABB aabb;
carve::csg::Octree octree;
// *** construction of Polyhedron objects
Polyhedron(const Polyhedron &);
// copy a single manifold
Polyhedron(const Polyhedron &, int m_id);
// copy a subset of manifolds
Polyhedron(const Polyhedron &, const std::vector<bool> &selected_manifolds);
Polyhedron(std::vector<face_t > &_faces,
std::vector<vertex_t > &_vertices,
bool _recalc = false);
Polyhedron(std::vector<face_t > &_faces,
bool _recalc = false);
Polyhedron(std::list<face_t > &_faces,
bool _recalc = false);
Polyhedron(const std::vector<carve::geom3d::Vector> &vertices,
int n_faces,
const std::vector<int> &face_indices);
~Polyhedron();
// *** containment queries
void testVertexAgainstClosedManifolds(const carve::geom3d::Vector &v,
std::map<int, PointClass> &result,
bool ignore_orentation) const;
PointClass containsVertex(const carve::geom3d::Vector &v,
const face_t **hit_face = NULL,
bool even_odd = false,
int manifold_id = -1) const;
// *** locality queries
void findEdgesNear(const carve::geom::aabb<3> &aabb, std::vector<const edge_t *> &edges) const;
void findEdgesNear(const carve::geom3d::LineSegment &l, std::vector<const edge_t *> &edges) const;
void findEdgesNear(const carve::geom3d::Vector &v, std::vector<const edge_t *> &edges) const;
void findEdgesNear(const face_t &face, std::vector<const edge_t *> &edges) const;
void findEdgesNear(const edge_t &edge, std::vector<const edge_t *> &edges) const;
void findFacesNear(const carve::geom::aabb<3> &aabb, std::vector<const face_t *> &faces) const;
void findFacesNear(const carve::geom3d::LineSegment &l, std::vector<const face_t *> &faces) const;
void findFacesNear(const edge_t &edge, std::vector<const face_t *> &faces) const;
// *** manifold queries
inline bool vertexOnManifold(const vertex_t *v, int m_id) const;
inline bool edgeOnManifold(const edge_t *e, int m_id) const;
template<typename T>
int vertexManifolds(const vertex_t *v, T result) const;
template<typename T>
int edgeManifolds(const edge_t *e, T result) const;
size_t manifoldCount() const;
bool hasOpenManifolds() const;
// *** transformation
// flip face directions
void invertAll();
void invert(const std::vector<bool> &selected_manifolds);
void invert(int m_id);
void invert();
// matrix transform of vertices
void transform(const carve::math::Matrix &xform);
// arbitrary function transform of vertices
template<typename T>
void transform(const T &xform);
void print(std::ostream &) const;
void canonicalize();
};
std::ostream &operator<<(std::ostream &, const Polyhedron &);
}
}
|
