DT/SimplexAttribute.h at master · tgbudd/DT · GitHub

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
#ifndef SIMPLEX_ATTRIBUTE_H
#define SIMPLEX_ATTRIBUTE_H

#include <vector>

#include "Triangulation.h"
#include "Vertex.h"
#include "Triangle.h"
#include "Edge.h"

template <typename simplex_t, typename T>
class SimplexAttribute {
public:
	typedef typename std::vector<T>::iterator iterator;
	iterator begin()
	{
		return data_.begin();
	}
	iterator end()
	{
		return data_.end();
	}
	virtual T& operator[](const simplex_t * simplex)
	{
		return data_[GetIndex(simplex)];
	}
	virtual const T& operator[](const simplex_t * simplex) const
	{
		return data_[GetIndex(simplex)];
	}
	std::vector<T> & data()
	{
		return data_;
	}
	const simplex_t * getSubject(iterator it)
	{
		return GetSimplex(it - data_.begin());
	}
protected:
	SimplexAttribute(size_t size) : data_(size)	{}
	SimplexAttribute(size_t size, const T & value) : data_(size,value) {}
private:
	virtual unsigned int GetIndex(const simplex_t * simplex) const = 0;
	virtual const simplex_t * GetSimplex(unsigned int index) const = 0;

	std::vector<T> data_;
};

template <typename simplex_t>
class SimplexAttribute<simplex_t,bool> {
public:
	typedef bool T;
	typedef std::vector<char>::iterator iterator;
	iterator begin()
	{
		return data_.begin();
	}
	iterator end()
	{
		return data_.end();
	}
	virtual char& operator[](const simplex_t * simplex)
	{
		return data_[GetIndex(simplex)];
	}
	virtual bool operator[](const simplex_t * simplex) const
	{
		return !!data_[GetIndex(simplex)];
	}
	const simplex_t * getSubject(iterator it)
	{
		return GetSimplex(it - data_.begin());
	}
protected:
	SimplexAttribute(size_t size) : data_(size)	{}
	SimplexAttribute(size_t size, const T & value) : data_(size,static_cast<char>(value)) {}
private:
	virtual unsigned int GetIndex(const simplex_t * simplex) const = 0;
	virtual const simplex_t * GetSimplex(unsigned int index) const = 0;

	std::vector<char> data_;
};

template <typename T>
class VertexAttribute : public SimplexAttribute<Vertex,T> {
public:
	VertexAttribute(const Triangulation * triangulation) :
		triangulation_(triangulation),
		SimplexAttribute<Vertex,T>(triangulation->NumberOfVertices())
	{}
	VertexAttribute(const Triangulation * triangulation, const T & value) :
		triangulation_(triangulation),
		SimplexAttribute<Vertex,T>(triangulation->NumberOfVertices(),value)
	{}
private:
	unsigned int GetIndex(const Vertex * simplex) const
	{
		return static_cast<unsigned int>(simplex->getId());
	}
	const Vertex * GetSimplex(unsigned int index) const
	{
		return triangulation_->getVertex(index);
	}
	const Triangulation * const triangulation_;
};

template <typename T>
class TriangleAttribute : public SimplexAttribute<Triangle,T> {
public:
	TriangleAttribute(const Triangulation * triangulation) :
		triangulation_(triangulation),
		SimplexAttribute<Triangle,T>(triangulation->NumberOfTriangles())
	{}
	TriangleAttribute(const Triangulation * triangulation, const T & value) :
		triangulation_(triangulation),
		SimplexAttribute<Triangle,T>(triangulation->NumberOfTriangles(),value)
	{}
private:
	unsigned int GetIndex(const Triangle * simplex) const
	{
		return static_cast<unsigned int>(simplex->getId());
	}
	const Triangle * GetSimplex(unsigned int index) const
	{
		return triangulation_->getTriangle(index);
	}

	const Triangulation * const triangulation_;
};

template <typename T>
class EdgeAttribute : public SimplexAttribute<Edge,T> {
public:
	EdgeAttribute(const Triangulation * triangulation) :
		triangulation_(triangulation),
		SimplexAttribute<Edge,T>(3*triangulation->NumberOfTriangles())
	{}
	EdgeAttribute(const Triangulation * triangulation, const T & value) :
		triangulation_(triangulation),
		SimplexAttribute<Edge,T>(3*triangulation->NumberOfTriangles(),value)
	{}
private:
	unsigned int GetIndex(const Edge * simplex) const
	{
		return static_cast<unsigned int>(3*simplex->getParent()->getId()+simplex->getId());
	}
	const Edge * GetSimplex(unsigned int index) const
	{
		return triangulation_->getTriangle(index/3)->getEdge(index%3);
	}
	const Triangulation * const triangulation_;
};


#endif