OpenVolumeMeshHandle.hh 6.96 KB
Newer Older
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
/*===========================================================================*\
 *                                                                           *
 *                            OpenVolumeMesh                                 *
 *        Copyright (C) 2011 by Computer Graphics Group, RWTH Aachen         *
 *                        www.openvolumemesh.org                             *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenVolumeMesh.                                     *
 *                                                                           *
 *  OpenVolumeMesh is free software: you can redistribute it and/or modify   *
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenVolumeMesh is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *  GNU Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenVolumeMesh.  If not,                              *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision$                                                         *
 *   $Date$                    *
 *   $LastChangedBy$                                                *
 *                                                                           *
\*===========================================================================*/

#ifndef OPENVOLUMEMESHHANDLE_HH_
#define OPENVOLUMEMESHHANDLE_HH_

Mike Kremer's avatar
Mike Kremer committed
46
#include <iostream>
47
#include <vector>
48
#include <OpenVolumeMesh/System/FunctionalInclude.hh>
49
#include <algorithm>
Mike Kremer's avatar
Mike Kremer committed
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
namespace OpenVolumeMesh {

// Define handle types in order to distinguish different entities by their indices
class OpenVolumeMeshHandle {
public:
    // Default constructor
	explicit OpenVolumeMeshHandle(int _idx) : idx_(_idx) {};

	OpenVolumeMeshHandle& operator=(int _idx) {
		idx_ = _idx;
		return *this;
	}

	OpenVolumeMeshHandle& operator=(const OpenVolumeMeshHandle& _idx) {
		idx_ = _idx.idx_;
		return *this;
	}

	inline bool is_valid() const { return idx_ != -1; }

	inline bool operator<(const OpenVolumeMeshHandle& _idx) const { return (this->idx_ < _idx.idx_); }

	inline bool operator<(int _idx) const { return idx_ < _idx; }

75
76
77
78
79
80
81
82
	inline bool operator>(const OpenVolumeMeshHandle& _idx) const { return (this->idx_ > _idx.idx_); }

    inline bool operator>(int _idx) const { return idx_ > _idx; }

	inline bool operator==(const OpenVolumeMeshHandle& _h) const { return _h.idx_ == this->idx_; }

	inline bool operator!=(const OpenVolumeMeshHandle& _h) const { return _h.idx_ != this->idx_; }

Mike Kremer's avatar
Mike Kremer committed
83
	inline const int& idx() const { return idx_; }
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

	void idx(const int& _idx) { idx_ = _idx; }

	void reset() { idx_ = -1; }

private:
	int idx_;
};

// Default entity handles

class VertexHandle   : public OpenVolumeMeshHandle { public: VertexHandle(int _idx = -1)   : OpenVolumeMeshHandle(_idx) {} };
class EdgeHandle     : public OpenVolumeMeshHandle { public: EdgeHandle(int _idx = -1)     : OpenVolumeMeshHandle(_idx) {} };
class FaceHandle     : public OpenVolumeMeshHandle { public: FaceHandle(int _idx = -1)     : OpenVolumeMeshHandle(_idx) {} };
class CellHandle     : public OpenVolumeMeshHandle { public: CellHandle(int _idx = -1)     : OpenVolumeMeshHandle(_idx) {} };
class HalfEdgeHandle : public OpenVolumeMeshHandle { public: HalfEdgeHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} };
class HalfFaceHandle : public OpenVolumeMeshHandle { public: HalfFaceHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} };

102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
// Helper class that is used to decrease all handles
// exceeding a certain threshold

class VHandleCorrection {
public:
    VHandleCorrection(VertexHandle _thld) : thld_(_thld) {}
    void correctValue(VertexHandle& _h) {
        if(_h > thld_) _h.idx(_h.idx() - 1);
    }
private:
    VertexHandle thld_;
};
class HEHandleCorrection {
public:
    HEHandleCorrection(HalfEdgeHandle _thld) : thld_(_thld) {}
    void correctVecValue(std::vector<HalfEdgeHandle>& _vec) {
118
        std::for_each(_vec.begin(), _vec.end(), fun::bind(&HEHandleCorrection::correctValue, this, fun::placeholders::_1));
119
120
121
122
123
124
125
126
127
128
129
    }
    void correctValue(HalfEdgeHandle& _h) {
        if(_h > thld_) _h.idx(_h.idx() - 2);
    }
private:
    HalfEdgeHandle thld_;
};
class HFHandleCorrection {
public:
    HFHandleCorrection(HalfFaceHandle _thld) : thld_(_thld) {}
    void correctVecValue(std::vector<HalfFaceHandle>& _vec) {
130
        std::for_each(_vec.begin(), _vec.end(), fun::bind(&HFHandleCorrection::correctValue, this, fun::placeholders::_1));
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
    }
    void correctValue(HalfFaceHandle& _h) {
        if(_h > thld_) _h.idx(_h.idx() - 2);
    }
private:
    HalfFaceHandle thld_;
};
class CHandleCorrection {
public:
    CHandleCorrection(CellHandle _thld) : thld_(_thld) {}
    void correctValue(CellHandle& _h) {
        if(_h > thld_) _h.idx(_h.idx() - 1);
    }
private:
    CellHandle thld_;
};

148
149
150
151
152
153
154
155
bool operator==(const int& _lhs, const OpenVolumeMeshHandle& _rhs);

bool operator==(const unsigned int& _lhs, const OpenVolumeMeshHandle& _rhs);

bool operator!=(const int& _lhs, const OpenVolumeMeshHandle& _rhs);

bool operator!=(const unsigned int& _lhs, const OpenVolumeMeshHandle& _rhs);

156
157
158
159
std::ostream& operator<<(std::ostream& _ostr, const OpenVolumeMeshHandle& _handle);

std::istream& operator>>(std::istream& _istr, OpenVolumeMeshHandle& _handle);

160
161
162
} // Namespace OpenVolumeMesh

#endif /* OPENVOLUMEMESHHANDLE_HH_ */