VCG Library
Loading...
Searching...
No Matches
component.h
1/****************************************************************************
2* VCGLib o o *
3* Visual and Computer Graphics Library o o *
4* _ O _ *
5* Copyright(C) 2004-2016 \/)\/ *
6* Visual Computing Lab /\/| *
7* ISTI - Italian National Research Council | *
8* \ *
9* All rights reserved. *
10* *
11* This program is free software; you can redistribute it and/or modify *
12* it under the terms of the GNU General Public License as published by *
13* the Free Software Foundation; either version 2 of the License, or *
14* (at your option) any later version. *
15* *
16* This program is distributed in the hope that it will be useful, *
17* but WITHOUT ANY WARRANTY; without even the implied warranty of *
18* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
20* for more details. *
21* *
22****************************************************************************/
23
24#ifndef __VCG_EDGE_PLUS_COMPONENT
25#define __VCG_EDGE_PLUS_COMPONENT
26
27#include <cassert>
28#include <vector>
29#include <string>
30
31#include <vcg/space/color4.h>
32
33
34namespace vcg {
35namespace edge {
36
41/*
42Some naming Rules
43All the Components that can be added to a vertex should be defined in the namespace edge:
44
45*/
46/*------------------------- EMPTY CORE COMPONENTS -----------------------------------------*/
47
48template <class T> class EmptyCore: public T
49{
50public:
51 inline typename T::VertexType * & V( const int j ) { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
52 inline typename T::VertexType * const & V( const int j ) const { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
53 inline typename T::VertexType * cV( const int j ) const { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
54 inline typename T::CoordType & P( const int j ) { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
55 inline const typename T::CoordType & P( const int j ) const { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
56 inline const typename T::CoordType & cP( const int j ) const { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
57 static bool HasEVAdjacency() { return false; }
58 static bool HasVertexRef() { return false; }
59
60 typedef vcg::Color4b ColorType;
61 ColorType &C() { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
62 ColorType cC() const { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
63 static bool HasColor() { return false; }
64 inline bool IsColorEnabled() const { return T::EdgeType::HasColor(); }
65
66
67 typedef float QualityType;
68 QualityType &Q() { static QualityType dummyQuality(0); assert(0); return dummyQuality; }
69 QualityType cQ() const { static QualityType dummyQuality(0); assert(0); return dummyQuality; }
70 static bool HasQuality() { return false; }
71 inline bool IsQualityEnabled() const { return T::EdgeType::HasQuality(); }
72
73 typedef int MarkType;
74 inline void InitIMark() { }
75 inline int cIMark() const { assert(0); static int tmp=-1; return tmp;}
76 inline int &IMark() { assert(0); static int tmp=-1; return tmp;}
77 static bool HasMark() { return false; }
78 inline bool IsMarkEnabled( ) const { return T::EdgeType::HasMark(); }
79
80
81 typedef int FlagType;
82 int &Flags() { static int dummyflags(0); assert(0); return dummyflags; }
83 int Flags() const { return 0; }
84 static bool HasFlags() { return false; }
85
86 typename T::EdgePointer &VEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
87 typename T::EdgePointer cVEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
88 int &VEi(const int &){static int z=0; assert(0); return z;}
89 int VEi(const int &) const {static int z=0; assert(0); return z;}
90 int cVEi(const int &) const {static int z=0; assert(0); return z;}
91 static bool HasVEAdjacency() { return false; }
92
93 typename T::EdgePointer &EEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
94 typename T::EdgePointer cEEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
95 int &EEi(const int &){static int z=0; assert(0); return z;}
96 int cEEi(const int &) const {static int z=0; assert(0); return z;}
97 static bool HasEEAdjacency() { return false; }
98
99 typename T::HEdgePointer &EHp( ) { static typename T::HEdgePointer hp=0; assert(0); return hp; }
100 typename T::HEdgePointer cEHp( ) const { static typename T::HEdgePointer hp=0; assert(0); return hp; }
101 static bool HasEHAdjacency() { return false; }
102
103 typename T::FacePointer &EFp() { static typename T::FacePointer fp=0; assert(0); return fp; }
104 typename T::FacePointer cEFp() const { static typename T::FacePointer fp=0; assert(0); return fp; }
105 int &EFi() {static int z=0; return z;}
106 int &cEFi() const {static int z=0; return z;}
107 static bool HasEFAdjacency() { return false; }
108
109 template <class LeftF>
110 void ImportData(const LeftF & leftF) {T::ImportData(leftF);}
111 static void Name(std::vector<std::string> & name){T::Name(name);}
112};
113
114/*-------------------------- VertexRef ----------------------------------------*/
120template <class T> class VertexRef: public T {
121public:
122 VertexRef(){
123 v[0]=0;
124 v[1]=0;
125 }
126
127 typedef typename T::VertexType::CoordType CoordType;
128 typedef typename T::VertexType::ScalarType ScalarType;
129
130 inline typename T::VertexType * & V( const int j ) { assert(j>=0 && j<2); return v[j]; }
131 inline typename T::VertexType * const & V( const int j ) const { assert(j>=0 && j<2); return v[j]; }
132 inline typename T::VertexType * cV( const int j ) const { assert(j>=0 && j<2); return v[j]; }
133
135 inline CoordType & P( const int j ) { assert(j>=0 && j<2); return v[j]->P();}
136 inline const CoordType & P( const int j ) const { assert(j>=0 && j<2); return v[j]->P();}
137 inline const CoordType & cP( const int j ) const { assert(j>=0 && j<2); return v[j]->P();}
138
142 inline typename T::VertexType * & V0( const int j ) { return V(j);}
143 inline typename T::VertexType * & V1( const int j ) { return V((j+1)%2);}
144 inline const typename T::VertexType * const & V0( const int j ) const { return V(j);}
145 inline const typename T::VertexType * const & V1( const int j ) const { return V((j+1)%2);}
146 inline const typename T::VertexType * const & cV0( const int j ) const { return cV(j);}
147 inline const typename T::VertexType * const & cV1( const int j ) const { return cV((j+1)%2);}
148
150 inline CoordType & P0( const int j ) { return V(j)->P();}
151 inline CoordType & P1( const int j ) { return V((j+1)%2)->P();}
152 inline const CoordType & P0( const int j ) const { return V(j)->P();}
153 inline const CoordType & P1( const int j ) const { return V((j+1)%2)->P();}
154 inline const CoordType & cP0( const int j ) const { return cV(j)->P();}
155 inline const CoordType & cP1( const int j ) const { return cV((j+1)%2)->P();}
156
157 template <class LeftF>
158 void ImportData(const LeftF & leftF){ T::ImportData(leftF);}
159
160 static bool HasEVAdjacency() { return true; }
161 static bool HasVertexRef() { return true; }
162 static void Name(std::vector<std::string> & name){name.push_back(std::string("VertexRef"));T::Name(name);}
163
164
165private:
166 typename T::VertexType *v[2];
167};
168
169template <class T> class EVAdj : public VertexRef<T>{};
170
171
172/*-------------------------- INCREMENTAL MARK ----------------------------------------*/
173
178template <class T> class Mark: public T {
179public:
180 Mark():_imark(0){}
181 static bool HasMark() { return true; }
182 static bool HasMarkOcc() { return true; }
183 inline void InitIMark() { _imark = 0; }
184 inline int & IMark() { return _imark;}
185 inline int cIMark() const { return _imark;}
186
187 template < class RightValueType>
188 void ImportData(const RightValueType & rightE )
189 {
190 if(rightE.IsMarkEnabled())
191 IMark() = rightE.cIMark();
192 T::ImportData(rightE);
193 }
194 static void Name(std::vector<std::string> & name){name.push_back(std::string("Mark"));T::Name(name);}
195
196private:
197 int _imark;
198};
199
200/*------------------------- FLAGS -----------------------------------------*/
205template <class T> class BitFlags: public T {
206public:
207 BitFlags(){_flags=0;}
208 typedef int FlagType;
209 int &Flags() {return _flags; }
210 int Flags() const {return _flags; }
211 template < class LeftV>
212 void ImportData(const LeftV & left ) { Flags() = left.Flags(); T::ImportData( left); }
213 static bool HasFlags() { return true; }
214 static void Name(std::vector<std::string> & name){name.push_back(std::string("BitFlags"));T::Name(name);}
215
216private:
217 int _flags;
218};
219
220/*-------------------------- Color ----------------------------------*/
226template <class A, class T> class Color: public T {
227public:
228 Color():_color(vcg::Color4b::White) {}
229 typedef A ColorType;
230 ColorType &C() { return _color; }
231 const ColorType &C() const { return _color; }
232 const ColorType &cC() const { return _color; }
233 template < class LeftV>
234 void ImportData(const LeftV & left ) { if (left.IsColorEnabled()) C() = left.cC(); T::ImportData( left); }
235 static bool HasColor() { return true; }
236 static void Name(std::vector<std::string> & name){name.push_back(std::string("Color"));T::Name(name);}
237
238private:
239 ColorType _color;
240};
241
242template <class TT> class Color4b: public edge::Color<vcg::Color4b, TT> {
243public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Color4b"));TT::Name(name);}
244};
245
246/*-------------------------- Quality ----------------------------------*/
253template <class A, class TT> class Quality: public TT {
254public:
255 typedef A QualityType;
256 QualityType &Q() { return _quality; }
257 const QualityType & cQ() const {return _quality; }
258 template < class LeftV>
259 void ImportData(const LeftV & left ) { if (left.IsQualityEnabled()) Q() = left.cQ(); TT::ImportData( left); }
260 static bool HasQuality() { return true; }
261 static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality"));TT::Name(name);}
262
263private:
264 QualityType _quality;
265};
266
267template <class TT> class Qualitys: public Quality<short, TT> {
268public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Qualitys"));TT::Name(name);}
269};
270template <class TT> class Qualityf: public Quality<float, TT> {
271public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Qualityf"));TT::Name(name);}
272};
273template <class TT> class Qualityd: public Quality<double, TT> {
274public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Qualityd"));TT::Name(name);}
275};
276
277/*----------------------------- VEADJ ------------------------------*/
285template <class T> class VEAdj: public T {
286public:
287 VEAdj(){_ep[0]=0;_ep[1]=0;_zp[0]=-1;_zp[1]=-1;}
288 typename T::EdgePointer &VEp(const int & i) {return _ep[i]; }
289 typename T::EdgePointer cVEp(const int & i) const {return _ep[i]; }
290 int &VEi(const int & i){ return _zp[i];}
291 int VEi(const int & i)const {return _zp[i];}
292 int cVEi(const int &i )const {return _zp[i];}
293
294 template < class LeftV>
295 void ImportData(const LeftV & left ) { T::ImportData( left); }
296 static bool HasVEAdjacency() { return true; }
297 static bool HasVEAdjacencyOcc() { return true; }
298 static void Name(std::vector<std::string> & name){name.push_back(std::string("VEAdj"));T::Name(name);}
299
300private:
301 typename T::EdgePointer _ep[2] ;
302 int _zp[2] ;
303};
304
305/*----------------------------- EEADJ ------------------------------*/
319template <class T> class EEAdj: public T {
320public:
321 EEAdj(){_ep[0]=0;_ep[1]=0;_zp[0]=-1;_zp[1]=-1;}
322 typename T::EdgePointer &EEp(const int & i) {return _ep[i]; }
323 typename T::EdgePointer cEEp(const int & i) const {return _ep[i]; }
324 int &EEi(const int & i){ return _zp[i];}
325 int cEEi(const int &i )const {return _zp[i];}
326
327 template < class LeftV>
328 void ImportData(const LeftV & left ) { T::ImportData( left); }
329 static bool HasEEAdjacency() { return true; }
330 static bool HasEEAdjacencyOcc() { return true; }
331 static void Name(std::vector<std::string> & name){name.push_back(std::string("EEAdj"));T::Name(name);}
332
333private:
334 typename T::EdgePointer _ep[2] ;
335 int _zp[2] ;
336};
337
338/*----------------------------- EHADJ ------------------------------*/
339template <class T> class EHAdj: public T {
340public:
341 EHAdj(){_hp=0;}
342 typename T::HEdgePointer &EHp( ) {return _hp ; }
343 const typename T::HEdgePointer cEHp( ) const {return _hp ; }
344
345 template < class LeftV>
346 void ImportData(const LeftV & left ) { T::ImportData( left); }
347 static bool HasEHAdjacency() { return true; }
348 static bool HasEHAdjacencyOcc() { return true; }
349 static void Name(std::vector<std::string> & name){name.push_back(std::string("EHAdj"));T::Name(name);}
350
351private:
352 typename T::HEdgePointer _hp ;
353};
354
355/*----------------------------- EFADJ ------------------------------*/
363template <class T> class EFAdj: public T {
364public:
365 EFAdj(){_fp=0;}
366 typename T::FacePointer &EFp() {return _fp; }
367 typename T::FacePointer cEFp() const {return _fp; }
368 int &EFi() {return _zp; }
369 int cEFi() const {return _zp; }
370 template < class LeftV>
371 void ImportData(const LeftV & left ) { T::ImportData( left); }
372 static bool HasEFAdjacency() { return true; }
373 static bool HasEFAdjacencyOcc() { return true; }
374 static void Name(std::vector<std::string> & name){name.push_back(std::string("EFAdj"));T::Name(name);}
375
376private:
377 typename T::FacePointer _fp ;
378 int _zp ;
379};
380 // End Doxygen EdgeComponentGroup
382} // end namespace edge
383}// end namespace vcg
384#endif
vcg::Color4
Definition: color4.h:41
vcg::edge::BitFlags
Component: Per edge Flags
Definition: component.h:205
vcg::edge::Color4b
Definition: component.h:242
vcg::edge::Color
Component: Per edge Color
Definition: component.h:226
vcg::edge::EEAdj
Component: Edge-Edge adjacency relation This component implement store the pointer (and index) of the...
Definition: component.h:319
vcg::edge::EFAdj
Component: Edge-Face adjacency relation This component implement store the pointer to a face sharing ...
Definition: component.h:363
vcg::edge::EHAdj
Definition: component.h:339
vcg::edge::EVAdj
Definition: component.h:169
vcg::edge::EmptyCore
Definition: component.h:49
vcg::edge::Mark
Component: Per edge Incremental Mark
Definition: component.h:178
vcg::edge::Quality
Component: Per edge quality
Definition: component.h:253
vcg::edge::Qualityd
Definition: component.h:273
vcg::edge::Qualityf
Definition: component.h:270
vcg::edge::Qualitys
Definition: component.h:267
vcg::edge::VEAdj
Component: Per vertex Vertex-Edge adjacency relation companion component This component implement one...
Definition: component.h:285
vcg::edge::VertexRef
The references to the two vertexes of a edge.
Definition: component.h:120
vcg::edge::VertexRef::P0
CoordType & P0(const int j)
Shortcuts to access points.
Definition: component.h:150
vcg::edge::VertexRef::P
CoordType & P(const int j)
Shortcuts to access points.
Definition: component.h:135
vcg::edge::VertexRef::V0
T::VertexType *& V0(const int j)
Definition: component.h:142
vcg
Definition: color4.h:30
Generated by doxygen 1.9.6 on Mon Dec 1 2025 17:19:44