cba3498629
This brings new copyright header which supports GPL2 and 3. It wasn't really an issue before because we had agreement with Tobias, but now it's all documented in sources.
875 lines
27 KiB
C++
875 lines
27 KiB
C++
// 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/geom.hpp>
|
|
#include <carve/geom3d.hpp>
|
|
#include <carve/tag.hpp>
|
|
#include <carve/djset.hpp>
|
|
#include <carve/aabb.hpp>
|
|
#include <carve/rtree.hpp>
|
|
|
|
#include <iostream>
|
|
|
|
namespace carve {
|
|
namespace poly {
|
|
class Polyhedron;
|
|
}
|
|
|
|
namespace mesh {
|
|
|
|
|
|
template<unsigned ndim> class Edge;
|
|
template<unsigned ndim> class Face;
|
|
template<unsigned ndim> class Mesh;
|
|
template<unsigned ndim> class MeshSet;
|
|
|
|
|
|
|
|
// A Vertex may participate in several meshes. If the Mesh belongs
|
|
// to a MeshSet, then the vertices come from the vertex_storage
|
|
// member of the MeshSet. This allows one to construct one or more
|
|
// Meshes out of sets of connected faces (possibly using vertices
|
|
// from a variety of MeshSets, and other storage), then create a
|
|
// MeshSet from the Mesh(es), causing the vertices to be
|
|
// collected, cloned and repointed into the MeshSet.
|
|
|
|
// Normally, in a half-edge structure, Vertex would have a member
|
|
// pointing to an incident edge, allowing the enumeration of
|
|
// adjacent faces and edges. Because we want to support vertex
|
|
// sharing between Meshes and groups of Faces, this is made more
|
|
// complex. If Vertex contained a list of incident edges, one from
|
|
// each disjoint face set, then this could be done (with the
|
|
// caveat that you'd need to pass in a Mesh pointer to the
|
|
// adjacency queries). However, it seems that this would
|
|
// unavoidably complicate the process of incorporating or removing
|
|
// a vertex into an edge.
|
|
|
|
// In most cases it is expected that a vertex will be arrived at
|
|
// via an edge or face in the mesh (implicit or explicit) of
|
|
// interest, so not storing this information will not hurt,
|
|
// overly.
|
|
template<unsigned ndim>
|
|
class Vertex : public tagable {
|
|
public:
|
|
typedef carve::geom::vector<ndim> vector_t;
|
|
typedef MeshSet<ndim> owner_t;
|
|
typedef carve::geom::aabb<ndim> aabb_t;
|
|
|
|
carve::geom::vector<ndim> v;
|
|
|
|
Vertex(const vector_t &_v) : tagable(), v(_v) {
|
|
}
|
|
|
|
Vertex() : tagable(), v() {
|
|
}
|
|
|
|
aabb_t getAABB() const {
|
|
return aabb_t(v, carve::geom::vector<ndim>::ZERO());
|
|
}
|
|
};
|
|
|
|
|
|
|
|
struct hash_vertex_pair {
|
|
template<unsigned ndim>
|
|
size_t operator()(const std::pair<Vertex<ndim> *, Vertex<ndim> *> &pair) const {
|
|
size_t r = (size_t)pair.first;
|
|
size_t s = (size_t)pair.second;
|
|
return r ^ ((s >> 16) | (s << 16));
|
|
}
|
|
template<unsigned ndim>
|
|
size_t operator()(const std::pair<const Vertex<ndim> *, const Vertex<ndim> *> &pair) const {
|
|
size_t r = (size_t)pair.first;
|
|
size_t s = (size_t)pair.second;
|
|
return r ^ ((s >> 16) | (s << 16));
|
|
}
|
|
};
|
|
|
|
|
|
|
|
struct vertex_distance {
|
|
template<unsigned ndim>
|
|
double operator()(const Vertex<ndim> &a, const Vertex<ndim> &b) const {
|
|
return carve::geom::distance(a.v, b.v);
|
|
}
|
|
|
|
template<unsigned ndim>
|
|
double operator()(const Vertex<ndim> *a, const Vertex<ndim> *b) const {
|
|
return carve::geom::distance(a->v, b->v);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
namespace detail {
|
|
template<typename list_t> struct list_iter_t;
|
|
template<typename list_t, typename mapping_t> struct mapped_list_iter_t;
|
|
}
|
|
|
|
|
|
|
|
// The half-edge structure proper (Edge) is maintained by Face
|
|
// instances. Together with Face instances, the half-edge
|
|
// structure defines a simple mesh (either one or two faces
|
|
// incident on each edge).
|
|
template<unsigned ndim>
|
|
class Edge : public tagable {
|
|
public:
|
|
typedef Vertex<ndim> vertex_t;
|
|
typedef Face<ndim> face_t;
|
|
|
|
vertex_t *vert;
|
|
face_t *face;
|
|
Edge *prev, *next, *rev;
|
|
|
|
private:
|
|
static void _link(Edge *a, Edge *b) {
|
|
a->next = b; b->prev = a;
|
|
}
|
|
|
|
static void _freeloop(Edge *s) {
|
|
Edge *e = s;
|
|
do {
|
|
Edge *n = e->next;
|
|
delete e;
|
|
e = n;
|
|
} while (e != s);
|
|
}
|
|
|
|
static void _setloopface(Edge *s, face_t *f) {
|
|
Edge *e = s;
|
|
do {
|
|
e->face = f;
|
|
e = e->next;
|
|
} while (e != s);
|
|
}
|
|
|
|
static size_t _looplen(Edge *s) {
|
|
Edge *e = s;
|
|
face_t *f = s->face;
|
|
size_t c = 0;
|
|
do {
|
|
++c;
|
|
CARVE_ASSERT(e->rev->rev == e);
|
|
CARVE_ASSERT(e->next->prev == e);
|
|
CARVE_ASSERT(e->face == f);
|
|
e = e->next;
|
|
} while (e != s);
|
|
return c;
|
|
}
|
|
|
|
public:
|
|
void validateLoop() {
|
|
Edge *e = this;
|
|
face_t *f = face;
|
|
size_t c = 0;
|
|
do {
|
|
++c;
|
|
CARVE_ASSERT(e->rev == NULL || e->rev->rev == e);
|
|
CARVE_ASSERT(e->next == e || e->next->vert != e->vert);
|
|
CARVE_ASSERT(e->prev == e || e->prev->vert != e->vert);
|
|
CARVE_ASSERT(e->next->prev == e);
|
|
CARVE_ASSERT(e->prev->next == e);
|
|
CARVE_ASSERT(e->face == f);
|
|
e = e->next;
|
|
} while (e != this);
|
|
CARVE_ASSERT(f == NULL || c == f->n_edges);
|
|
}
|
|
|
|
size_t loopLen() {
|
|
return _looplen(this);
|
|
}
|
|
|
|
Edge *mergeFaces();
|
|
|
|
Edge *removeHalfEdge();
|
|
|
|
// Remove and delete this edge.
|
|
Edge *removeEdge();
|
|
|
|
// Unlink this edge from its containing edge loop. disconnect
|
|
// rev links. The rev links of the previous edge also change, as
|
|
// its successor vertex changes.
|
|
void unlink();
|
|
|
|
// Insert this edge into a loop before other. If edge was
|
|
// already in a loop, it needs to be removed first.
|
|
void insertBefore(Edge *other);
|
|
|
|
// Insert this edge into a loop after other. If edge was
|
|
// already in a loop, it needs to be removed first.
|
|
void insertAfter(Edge *other);
|
|
|
|
size_t loopSize() const;
|
|
|
|
vertex_t *v1() { return vert; }
|
|
vertex_t *v2() { return next->vert; }
|
|
|
|
const vertex_t *v1() const { return vert; }
|
|
const vertex_t *v2() const { return next->vert; }
|
|
|
|
Edge *perimNext() const;
|
|
Edge *perimPrev() const;
|
|
|
|
double length2() const {
|
|
return (v1()->v - v2()->v).length2();
|
|
}
|
|
|
|
double length() const {
|
|
return (v1()->v - v2()->v).length();
|
|
}
|
|
|
|
Edge(vertex_t *_vert, face_t *_face);
|
|
|
|
~Edge();
|
|
};
|
|
|
|
|
|
|
|
// A Face contains a pointer to the beginning of the half-edge
|
|
// circular list that defines its boundary.
|
|
template<unsigned ndim>
|
|
class Face : public tagable {
|
|
public:
|
|
typedef Vertex<ndim> vertex_t;
|
|
typedef Edge<ndim> edge_t;
|
|
typedef Mesh<ndim> mesh_t;
|
|
|
|
typedef typename Vertex<ndim>::vector_t vector_t;
|
|
typedef carve::geom::aabb<ndim> aabb_t;
|
|
typedef carve::geom::plane<ndim> plane_t;
|
|
typedef carve::geom::vector<2> (*project_t)(const vector_t &);
|
|
typedef vector_t (*unproject_t)(const carve::geom::vector<2> &, const plane_t &);
|
|
|
|
struct vector_mapping {
|
|
typedef typename vertex_t::vector_t value_type;
|
|
|
|
value_type operator()(const carve::geom::vector<ndim> &v) const { return v; }
|
|
value_type operator()(const carve::geom::vector<ndim> *v) const { return *v; }
|
|
value_type operator()(const Edge<ndim> &e) const { return e.vert->v; }
|
|
value_type operator()(const Edge<ndim> *e) const { return e->vert->v; }
|
|
value_type operator()(const Vertex<ndim> &v) const { return v.v; }
|
|
value_type operator()(const Vertex<ndim> *v) const { return v->v; }
|
|
};
|
|
|
|
struct projection_mapping {
|
|
typedef carve::geom::vector<2> value_type;
|
|
project_t proj;
|
|
projection_mapping(project_t _proj) : proj(_proj) { }
|
|
value_type operator()(const carve::geom::vector<ndim> &v) const { return proj(v); }
|
|
value_type operator()(const carve::geom::vector<ndim> *v) const { return proj(*v); }
|
|
value_type operator()(const Edge<ndim> &e) const { return proj(e.vert->v); }
|
|
value_type operator()(const Edge<ndim> *e) const { return proj(e->vert->v); }
|
|
value_type operator()(const Vertex<ndim> &v) const { return proj(v.v); }
|
|
value_type operator()(const Vertex<ndim> *v) const { return proj(v->v); }
|
|
};
|
|
|
|
edge_t *edge;
|
|
size_t n_edges;
|
|
mesh_t *mesh;
|
|
size_t id;
|
|
|
|
plane_t plane;
|
|
project_t project;
|
|
unproject_t unproject;
|
|
|
|
private:
|
|
Face &operator=(const Face &other);
|
|
|
|
protected:
|
|
Face() : edge(NULL), n_edges(0), mesh(NULL), id(0), plane(), project(NULL), unproject(NULL) {
|
|
}
|
|
|
|
Face(const Face &other) :
|
|
edge(NULL), n_edges(other.n_edges), mesh(NULL), id(other.id),
|
|
plane(other.plane), project(other.project), unproject(other.unproject) {
|
|
}
|
|
|
|
project_t getProjector(bool positive_facing, int axis) const;
|
|
unproject_t getUnprojector(bool positive_facing, int axis) const;
|
|
|
|
public:
|
|
typedef detail::list_iter_t<Edge<ndim> > edge_iter_t;
|
|
typedef detail::list_iter_t<const Edge<ndim> > const_edge_iter_t;
|
|
|
|
edge_iter_t begin() { return edge_iter_t(edge, 0); }
|
|
edge_iter_t end() { return edge_iter_t(edge, n_edges); }
|
|
|
|
const_edge_iter_t begin() const { return const_edge_iter_t(edge, 0); }
|
|
const_edge_iter_t end() const { return const_edge_iter_t(edge, n_edges); }
|
|
|
|
bool containsPoint(const vector_t &p) const;
|
|
bool containsPointInProjection(const vector_t &p) const;
|
|
bool simpleLineSegmentIntersection(
|
|
const carve::geom::linesegment<ndim> &line,
|
|
vector_t &intersection) const;
|
|
IntersectionClass lineSegmentIntersection(
|
|
const carve::geom::linesegment<ndim> &line,
|
|
vector_t &intersection) const;
|
|
|
|
aabb_t getAABB() const;
|
|
|
|
bool recalc();
|
|
|
|
void clearEdges();
|
|
|
|
// build an edge loop in forward orientation from an iterator pair
|
|
template<typename iter_t>
|
|
void loopFwd(iter_t vbegin, iter_t vend);
|
|
|
|
// build an edge loop in reverse orientation from an iterator pair
|
|
template<typename iter_t>
|
|
void loopRev(iter_t vbegin, iter_t vend);
|
|
|
|
// initialize a face from an ordered list of vertices.
|
|
template<typename iter_t>
|
|
void init(iter_t begin, iter_t end);
|
|
|
|
// initialization of a triangular face.
|
|
void init(vertex_t *a, vertex_t *b, vertex_t *c);
|
|
|
|
// initialization of a quad face.
|
|
void init(vertex_t *a, vertex_t *b, vertex_t *c, vertex_t *d);
|
|
|
|
void getVertices(std::vector<vertex_t *> &verts) const;
|
|
void getProjectedVertices(std::vector<carve::geom::vector<2> > &verts) const;
|
|
|
|
projection_mapping projector() const {
|
|
return projection_mapping(project);
|
|
}
|
|
|
|
std::pair<double, double> rangeInDirection(const vector_t &v, const vector_t &b) const {
|
|
edge_t *e = edge;
|
|
double lo, hi;
|
|
lo = hi = carve::geom::dot(v, e->vert->v - b);
|
|
e = e->next;
|
|
for (; e != edge; e = e->next) {
|
|
double d = carve::geom::dot(v, e->vert->v - b);
|
|
lo = std::min(lo, d);
|
|
hi = std::max(hi, d);
|
|
}
|
|
return std::make_pair(lo, hi);
|
|
}
|
|
|
|
size_t nVertices() const {
|
|
return n_edges;
|
|
}
|
|
|
|
size_t nEdges() const {
|
|
return n_edges;
|
|
}
|
|
|
|
vector_t centroid() const;
|
|
|
|
static Face *closeLoop(edge_t *open_edge);
|
|
|
|
Face(edge_t *e) : edge(e), n_edges(0), mesh(NULL) {
|
|
do {
|
|
e->face = this;
|
|
n_edges++;
|
|
e = e->next;
|
|
} while (e != edge);
|
|
recalc();
|
|
}
|
|
|
|
Face(vertex_t *a, vertex_t *b, vertex_t *c) : edge(NULL), n_edges(0), mesh(NULL) {
|
|
init(a, b, c);
|
|
recalc();
|
|
}
|
|
|
|
Face(vertex_t *a, vertex_t *b, vertex_t *c, vertex_t *d) : edge(NULL), n_edges(0), mesh(NULL) {
|
|
init(a, b, c, d);
|
|
recalc();
|
|
}
|
|
|
|
template<typename iter_t>
|
|
Face(iter_t begin, iter_t end) : edge(NULL), n_edges(0), mesh(NULL) {
|
|
init(begin, end);
|
|
recalc();
|
|
}
|
|
|
|
template<typename iter_t>
|
|
Face *create(iter_t beg, iter_t end, bool reversed) const;
|
|
|
|
Face *clone(const vertex_t *old_base, vertex_t *new_base, std::unordered_map<const edge_t *, edge_t *> &edge_map) const;
|
|
|
|
void remove() {
|
|
edge_t *e = edge;
|
|
do {
|
|
if (e->rev) e->rev->rev = NULL;
|
|
e = e->next;
|
|
} while (e != edge);
|
|
}
|
|
|
|
void invert() {
|
|
// We invert the direction of the edges of the face in this
|
|
// way so that the edge rev pointers (if any) are still
|
|
// correct. It is expected that invert() will be called on
|
|
// every other face in the mesh, too, otherwise everything
|
|
// will get messed up.
|
|
|
|
{
|
|
// advance vertices.
|
|
edge_t *e = edge;
|
|
vertex_t *va = e->vert;
|
|
do {
|
|
e->vert = e->next->vert;
|
|
e = e->next;
|
|
} while (e != edge);
|
|
edge->prev->vert = va;
|
|
}
|
|
|
|
{
|
|
// swap prev and next pointers.
|
|
edge_t *e = edge;
|
|
do {
|
|
edge_t *n = e->next;
|
|
std::swap(e->prev, e->next);
|
|
e = n;
|
|
} while (e != edge);
|
|
}
|
|
|
|
plane.negate();
|
|
|
|
int da = carve::geom::largestAxis(plane.N);
|
|
|
|
project = getProjector(plane.N.v[da] > 0, da);
|
|
unproject = getUnprojector(plane.N.v[da] > 0, da);
|
|
}
|
|
|
|
void canonicalize();
|
|
|
|
~Face() {
|
|
clearEdges();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
struct MeshOptions {
|
|
bool opt_avoid_cavities;
|
|
|
|
MeshOptions() :
|
|
opt_avoid_cavities(false) {
|
|
}
|
|
|
|
MeshOptions &avoid_cavities(bool val) {
|
|
opt_avoid_cavities = val;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
namespace detail {
|
|
class FaceStitcher {
|
|
FaceStitcher();
|
|
FaceStitcher(const FaceStitcher &);
|
|
FaceStitcher &operator=(const FaceStitcher &);
|
|
|
|
typedef Vertex<3> vertex_t;
|
|
typedef Edge<3> edge_t;
|
|
typedef Face<3> face_t;
|
|
|
|
typedef std::pair<const vertex_t *, const vertex_t *> vpair_t;
|
|
typedef std::list<edge_t *> edgelist_t;
|
|
typedef std::unordered_map<vpair_t, edgelist_t, carve::mesh::hash_vertex_pair> edge_map_t;
|
|
typedef std::unordered_map<const vertex_t *, std::set<const vertex_t *> > edge_graph_t;
|
|
|
|
MeshOptions opts;
|
|
|
|
edge_map_t edges;
|
|
edge_map_t complex_edges;
|
|
|
|
carve::djset::djset face_groups;
|
|
std::vector<bool> is_open;
|
|
|
|
edge_graph_t edge_graph;
|
|
|
|
struct EdgeOrderData {
|
|
size_t group_id;
|
|
bool is_reversed;
|
|
carve::geom::vector<3> face_dir;
|
|
edge_t *edge;
|
|
|
|
EdgeOrderData(edge_t *_edge, size_t _group_id, bool _is_reversed) :
|
|
group_id(_group_id),
|
|
is_reversed(_is_reversed) {
|
|
if (is_reversed) {
|
|
face_dir = -(_edge->face->plane.N);
|
|
} else {
|
|
face_dir = (_edge->face->plane.N);
|
|
}
|
|
edge = _edge;
|
|
}
|
|
|
|
struct TestGroups {
|
|
size_t fwd, rev;
|
|
|
|
TestGroups(size_t _fwd, size_t _rev) : fwd(_fwd), rev(_rev) {
|
|
}
|
|
|
|
bool operator()(const EdgeOrderData &eo) const {
|
|
return eo.group_id == (eo.is_reversed ? rev : fwd);
|
|
}
|
|
};
|
|
|
|
struct Cmp {
|
|
carve::geom::vector<3> edge_dir;
|
|
carve::geom::vector<3> base_dir;
|
|
|
|
Cmp(const carve::geom::vector<3> &_edge_dir,
|
|
const carve::geom::vector<3> &_base_dir) :
|
|
edge_dir(_edge_dir),
|
|
base_dir(_base_dir) {
|
|
}
|
|
bool operator()(const EdgeOrderData &a, const EdgeOrderData &b) const;
|
|
};
|
|
};
|
|
|
|
void extractConnectedEdges(std::vector<const vertex_t *>::iterator begin,
|
|
std::vector<const vertex_t *>::iterator end,
|
|
std::vector<std::vector<Edge<3> *> > &efwd,
|
|
std::vector<std::vector<Edge<3> *> > &erev);
|
|
|
|
size_t faceGroupID(const Face<3> *face);
|
|
size_t faceGroupID(const Edge<3> *edge);
|
|
|
|
void resolveOpenEdges();
|
|
|
|
void fuseEdges(std::vector<Edge<3> *> &fwd,
|
|
std::vector<Edge<3> *> &rev);
|
|
|
|
void joinGroups(std::vector<std::vector<Edge<3> *> > &efwd,
|
|
std::vector<std::vector<Edge<3> *> > &erev,
|
|
size_t fwd_grp,
|
|
size_t rev_grp);
|
|
|
|
void matchOrderedEdges(const std::vector<std::vector<EdgeOrderData> >::iterator begin,
|
|
const std::vector<std::vector<EdgeOrderData> >::iterator end,
|
|
std::vector<std::vector<Edge<3> *> > &efwd,
|
|
std::vector<std::vector<Edge<3> *> > &erev);
|
|
|
|
void reorder(std::vector<EdgeOrderData> &ordering, size_t fwd_grp);
|
|
|
|
void orderForwardAndReverseEdges(std::vector<std::vector<Edge<3> *> > &efwd,
|
|
std::vector<std::vector<Edge<3> *> > &erev,
|
|
std::vector<std::vector<EdgeOrderData> > &result);
|
|
|
|
void edgeIncidentGroups(const vpair_t &e,
|
|
const edge_map_t &all_edges,
|
|
std::pair<std::set<size_t>, std::set<size_t> > &groups);
|
|
|
|
void buildEdgeGraph(const edge_map_t &all_edges);
|
|
void extractPath(std::vector<const vertex_t *> &path);
|
|
void removePath(const std::vector<const vertex_t *> &path);
|
|
void matchSimpleEdges();
|
|
void construct();
|
|
|
|
template<typename iter_t>
|
|
void initEdges(iter_t begin, iter_t end);
|
|
|
|
template<typename iter_t>
|
|
void build(iter_t begin, iter_t end, std::vector<Mesh<3> *> &meshes);
|
|
|
|
public:
|
|
FaceStitcher(const MeshOptions &_opts);
|
|
|
|
template<typename iter_t>
|
|
void create(iter_t begin, iter_t end, std::vector<Mesh<3> *> &meshes);
|
|
};
|
|
}
|
|
|
|
|
|
|
|
// A Mesh is a connected set of faces. It may be open (some edges
|
|
// have NULL rev members), or closed. On destruction, a Mesh
|
|
// should free its Faces (which will in turn free Edges, but not
|
|
// Vertices). A Mesh is edge-connected, which is to say that each
|
|
// face in the mesh shares an edge with at least one other face in
|
|
// the mesh. Touching at a vertex is not sufficient. This means
|
|
// that the perimeter of an open mesh visits each vertex no more
|
|
// than once.
|
|
template<unsigned ndim>
|
|
class Mesh {
|
|
public:
|
|
typedef Vertex<ndim> vertex_t;
|
|
typedef Edge<ndim> edge_t;
|
|
typedef Face<ndim> face_t;
|
|
typedef carve::geom::aabb<ndim> aabb_t;
|
|
typedef MeshSet<ndim> meshset_t;
|
|
|
|
std::vector<face_t *> faces;
|
|
|
|
// open_edges is a vector of all the edges in the mesh that
|
|
// don't have a matching edge in the opposite direction.
|
|
std::vector<edge_t *> open_edges;
|
|
|
|
// closed_edges is a vector of all the edges in the mesh that
|
|
// have a matching edge in the opposite direction, and whose
|
|
// address is lower than their counterpart. (i.e. for each pair
|
|
// of adjoining faces, one of the two half edges is stored in
|
|
// closed_edges).
|
|
std::vector<edge_t *> closed_edges;
|
|
|
|
bool is_negative;
|
|
|
|
meshset_t *meshset;
|
|
|
|
protected:
|
|
Mesh(std::vector<face_t *> &_faces,
|
|
std::vector<edge_t *> &_open_edges,
|
|
std::vector<edge_t *> &_closed_edges,
|
|
bool _is_negative);
|
|
|
|
public:
|
|
Mesh(std::vector<face_t *> &_faces);
|
|
|
|
~Mesh();
|
|
|
|
template<typename iter_t>
|
|
static void create(iter_t begin, iter_t end, std::vector<Mesh<ndim> *> &meshes, const MeshOptions &opts);
|
|
|
|
aabb_t getAABB() const {
|
|
return aabb_t(faces.begin(), faces.end());
|
|
}
|
|
|
|
bool isClosed() const {
|
|
return open_edges.size() == 0;
|
|
}
|
|
|
|
bool isNegative() const {
|
|
return is_negative;
|
|
}
|
|
|
|
double volume() const {
|
|
if (is_negative || !faces.size()) return 0.0;
|
|
|
|
double vol = 0.0;
|
|
typename vertex_t::vector_t origin = faces[0]->edge->vert->v;
|
|
|
|
for (size_t f = 0; f < faces.size(); ++f) {
|
|
face_t *face = faces[f];
|
|
edge_t *e1 = face->edge;
|
|
for (edge_t *e2 = e1->next ;e2->next != e1; e2 = e2->next) {
|
|
vol += carve::geom3d::tetrahedronVolume(e1->vert->v, e2->vert->v, e2->next->vert->v, origin);
|
|
}
|
|
}
|
|
return vol;
|
|
}
|
|
|
|
struct IsClosed {
|
|
bool operator()(const Mesh &mesh) const { return mesh.isClosed(); }
|
|
bool operator()(const Mesh *mesh) const { return mesh->isClosed(); }
|
|
};
|
|
|
|
struct IsNegative {
|
|
bool operator()(const Mesh &mesh) const { return mesh.isNegative(); }
|
|
bool operator()(const Mesh *mesh) const { return mesh->isNegative(); }
|
|
};
|
|
|
|
void cacheEdges();
|
|
|
|
int orientationAtVertex(edge_t *);
|
|
void calcOrientation();
|
|
|
|
void recalc() {
|
|
for (size_t i = 0; i < faces.size(); ++i) faces[i]->recalc();
|
|
calcOrientation();
|
|
}
|
|
|
|
void invert() {
|
|
for (size_t i = 0; i < faces.size(); ++i) {
|
|
faces[i]->invert();
|
|
}
|
|
if (isClosed()) is_negative = !is_negative;
|
|
}
|
|
|
|
Mesh *clone(const vertex_t *old_base, vertex_t *new_base) const;
|
|
};
|
|
|
|
// A MeshSet manages vertex storage, and a collection of meshes.
|
|
// It should be easy to turn a vertex pointer into its index in
|
|
// its MeshSet vertex_storage.
|
|
template<unsigned ndim>
|
|
class MeshSet {
|
|
MeshSet();
|
|
MeshSet(const MeshSet &);
|
|
MeshSet &operator=(const MeshSet &);
|
|
|
|
template<typename iter_t>
|
|
void _init_from_faces(iter_t begin, iter_t end, const MeshOptions &opts);
|
|
|
|
public:
|
|
typedef Vertex<ndim> vertex_t;
|
|
typedef Edge<ndim> edge_t;
|
|
typedef Face<ndim> face_t;
|
|
typedef Mesh<ndim> mesh_t;
|
|
typedef carve::geom::aabb<ndim> aabb_t;
|
|
|
|
std::vector<vertex_t> vertex_storage;
|
|
std::vector<mesh_t *> meshes;
|
|
|
|
public:
|
|
template<typename face_type>
|
|
struct FaceIter : public std::iterator<std::random_access_iterator_tag, face_type> {
|
|
typedef std::iterator<std::random_access_iterator_tag, face_type> super;
|
|
typedef typename super::difference_type difference_type;
|
|
|
|
const MeshSet<ndim> *obj;
|
|
size_t mesh, face;
|
|
|
|
FaceIter(const MeshSet<ndim> *_obj, size_t _mesh, size_t _face);
|
|
|
|
void fwd(size_t n);
|
|
void rev(size_t n);
|
|
void adv(int n);
|
|
|
|
FaceIter operator++(int) { FaceIter tmp = *this; tmp.fwd(1); return tmp; }
|
|
FaceIter operator+(int v) { FaceIter tmp = *this; tmp.adv(v); return tmp; }
|
|
FaceIter &operator++() { fwd(1); return *this; }
|
|
FaceIter &operator+=(int v) { adv(v); return *this; }
|
|
|
|
FaceIter operator--(int) { FaceIter tmp = *this; tmp.rev(1); return tmp; }
|
|
FaceIter operator-(int v) { FaceIter tmp = *this; tmp.adv(-v); return tmp; }
|
|
FaceIter &operator--() { rev(1); return *this; }
|
|
FaceIter &operator-=(int v) { adv(-v); return *this; }
|
|
|
|
difference_type operator-(const FaceIter &other) const;
|
|
|
|
bool operator==(const FaceIter &other) const {
|
|
return obj == other.obj && mesh == other.mesh && face == other.face;
|
|
}
|
|
bool operator!=(const FaceIter &other) const {
|
|
return !(*this == other);
|
|
}
|
|
bool operator<(const FaceIter &other) const {
|
|
CARVE_ASSERT(obj == other.obj);
|
|
return mesh < other.mesh || (mesh == other.mesh && face < other.face);
|
|
}
|
|
bool operator>(const FaceIter &other) const {
|
|
return other < *this;
|
|
}
|
|
bool operator<=(const FaceIter &other) const {
|
|
return !(other < *this);
|
|
}
|
|
bool operator>=(const FaceIter &other) const {
|
|
return !(*this < other);
|
|
}
|
|
|
|
face_type operator*() const {
|
|
return obj->meshes[mesh]->faces[face];
|
|
}
|
|
};
|
|
|
|
typedef FaceIter<const face_t *> const_face_iter;
|
|
typedef FaceIter<face_t *> face_iter;
|
|
|
|
face_iter faceBegin() { return face_iter(this, 0, 0); }
|
|
face_iter faceEnd() { return face_iter(this, meshes.size(), 0); }
|
|
|
|
const_face_iter faceBegin() const { return const_face_iter(this, 0, 0); }
|
|
const_face_iter faceEnd() const { return const_face_iter(this, meshes.size(), 0); }
|
|
|
|
aabb_t getAABB() const {
|
|
return aabb_t(meshes.begin(), meshes.end());
|
|
}
|
|
|
|
template<typename func_t>
|
|
void transform(func_t func) {
|
|
for (size_t i = 0; i < vertex_storage.size(); ++i) {
|
|
vertex_storage[i].v = func(vertex_storage[i].v);
|
|
}
|
|
for (size_t i = 0; i < meshes.size(); ++i) {
|
|
meshes[i]->recalc();
|
|
}
|
|
}
|
|
|
|
MeshSet(const std::vector<typename vertex_t::vector_t> &points,
|
|
size_t n_faces,
|
|
const std::vector<int> &face_indices,
|
|
const MeshOptions &opts = MeshOptions());
|
|
|
|
// Construct a mesh set from a set of disconnected faces. Takes
|
|
// posession of the face pointers.
|
|
MeshSet(std::vector<face_t *> &faces,
|
|
const MeshOptions &opts = MeshOptions());
|
|
|
|
MeshSet(std::list<face_t *> &faces,
|
|
const MeshOptions &opts = MeshOptions());
|
|
|
|
MeshSet(std::vector<vertex_t> &_vertex_storage,
|
|
std::vector<mesh_t *> &_meshes);
|
|
|
|
// This constructor consolidates and rewrites vertex pointers in
|
|
// each mesh, repointing them to local storage.
|
|
MeshSet(std::vector<mesh_t *> &_meshes);
|
|
|
|
MeshSet *clone() const;
|
|
|
|
~MeshSet();
|
|
|
|
bool isClosed() const {
|
|
for (size_t i = 0; i < meshes.size(); ++i) {
|
|
if (!meshes[i]->isClosed()) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void invert() {
|
|
for (size_t i = 0; i < meshes.size(); ++i) {
|
|
meshes[i]->invert();
|
|
}
|
|
}
|
|
|
|
void collectVertices();
|
|
|
|
void canonicalize();
|
|
|
|
void separateMeshes();
|
|
};
|
|
|
|
|
|
|
|
carve::PointClass classifyPoint(
|
|
const carve::mesh::MeshSet<3> *meshset,
|
|
const carve::geom::RTreeNode<3, carve::mesh::Face<3> *> *face_rtree,
|
|
const carve::geom::vector<3> &v,
|
|
bool even_odd = false,
|
|
const carve::mesh::Mesh<3> *mesh = NULL,
|
|
const carve::mesh::Face<3> **hit_face = NULL);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
mesh::MeshSet<3> *meshFromPolyhedron(const poly::Polyhedron *, int manifold_id);
|
|
poly::Polyhedron *polyhedronFromMesh(const mesh::MeshSet<3> *, int manifold_id);
|
|
|
|
|
|
|
|
};
|
|
|
|
#include <carve/mesh_impl.hpp>
|