blob: d73a086f81d06d747c2b6eccaba8e040a3f6c39d (
plain)
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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
//
// Filename : FEdgeXDetector.h
// Author(s) : Stephane Grabli
// Purpose : Detects/flags/builds extended features edges on the
// WXEdge structure
// Date of creation : 26/10/2003
//
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) : Please refer to the COPYRIGHT file distributed
// with this source distribution.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef FEDGEXDETECTOR_H
# define FEDGEXDETECTOR_H
# include <vector>
# include "../system/FreestyleConfig.h"
# include "../geometry/Geom.h"
# include "../winged_edge/WXEdge.h"
# include "../winged_edge/Curvature.h"
# include "../system/ProgressBar.h"
using namespace Geometry;
/*! This class takes as input a WXEdge structure and fills it
*/
class LIB_VIEW_MAP_EXPORT FEdgeXDetector
{
public:
FEdgeXDetector() {
_pProgressBar = 0;
_computeViewIndependant = true;
_bbox_diagonal = 1.0;
_meanEdgeSize = 0;
_computeRidgesAndValleys = true;
_computeSuggestiveContours = true;
_computeMaterialBoundaries = true;
_sphereRadius = 1.0;
_orthographicProjection = false;
_faceSmoothness = false;
_changes = false;
_kr_derivative_epsilon = 0.0;
_creaseAngle = 0.7; // angle of 134.43 degrees
}
virtual ~FEdgeXDetector() {}
/*! Process shapes from a WingedEdge containing a list of WShapes */
virtual void processShapes(WingedEdge&);
// GENERAL STUFF
virtual void preProcessShape(WXShape* iShape);
virtual void preProcessFace(WXFace* iFace);
virtual void computeCurvatures(WXVertex *iVertex);
// SILHOUETTE
virtual void processSilhouetteShape(WXShape* iShape);
virtual void ProcessSilhouetteFace(WXFace *iFace);
virtual void ProcessSilhouetteEdge(WXEdge *iEdge);
// CREASE
virtual void processCreaseShape(WXShape* iShape);
virtual void ProcessCreaseEdge(WXEdge *iEdge);
/*! Sets the minimum angle for detecting crease edges
* \param angle
* The angular threshold in degrees (between 0 and 180) for detecting crease
* edges. An edge is considered a crease edge if the angle between two faces
* sharing the edge is smaller than the given threshold.
*/
inline void setCreaseAngle(real angle) {
if (angle < 0.0)
angle = 0.0;
else if (angle > 180.0)
angle = 180.0;
angle = cos(M_PI * (180.0 - angle) / 180.0);
if (angle != _creaseAngle){
_creaseAngle = angle;
_changes = true;
}
}
// BORDER
virtual void processBorderShape(WXShape* iShape);
virtual void ProcessBorderEdge(WXEdge *iEdge);
// RIDGES AND VALLEYS
virtual void processRidgesAndValleysShape(WXShape* iShape);
virtual void ProcessRidgeFace(WXFace *iFace);
// SUGGESTIVE CONTOURS
virtual void processSuggestiveContourShape(WXShape* iShape);
virtual void ProcessSuggestiveContourFace(WXFace *iFace);
virtual void postProcessSuggestiveContourShape(WXShape* iShape);
virtual void postProcessSuggestiveContourFace(WXFace *iFace);
/*! Sets the minimal derivative of the radial curvature for suggestive contours
* \param dkr
* The minimal derivative of the radial curvature
*/
inline void setSuggestiveContourKrDerivativeEpsilon(real dkr) {
if (dkr != _kr_derivative_epsilon){
_kr_derivative_epsilon = dkr;
_changes = true;
}
}
// MATERIAL BOUNDARY
virtual void processMaterialBoundaryShape(WXShape* iWShape);
virtual void ProcessMaterialBoundaryEdge(WXEdge *iEdge);
// EDGE MARKS
virtual void processEdgeMarksShape(WXShape* iShape);
virtual void ProcessEdgeMarks(WXEdge *iEdge);
// EVERYBODY
virtual void buildSmoothEdges(WXShape* iShape);
/*! Sets the current viewpoint */
inline void setViewpoint(const Vec3r& ivp) {_Viewpoint = ivp;}
inline void enableOrthographicProjection(bool b) {_orthographicProjection = b;}
inline void enableRidgesAndValleysFlag(bool b) {_computeRidgesAndValleys = b;}
inline void enableSuggestiveContours(bool b) {_computeSuggestiveContours = b;}
inline void enableMaterialBoundaries(bool b) {_computeMaterialBoundaries = b;}
inline void enableFaceSmoothness(bool b) {
if (b != _faceSmoothness) {
_faceSmoothness = b;
_changes=true;
}
}
inline void enableFaceMarks(bool b) {
if (b != _faceMarks) {
_faceMarks = b;
_changes=true;
}
}
/*! Sets the radius of the geodesic sphere around each vertex (for the curvature computation)
* \param r
* The radius of the sphere expressed as a ratio of the mean edge size
*/
inline void setSphereRadius(real r) {
if(r!=_sphereRadius){
_sphereRadius = r;
_changes=true;
}
}
inline void setProgressBar(ProgressBar *iProgressBar) {_pProgressBar = iProgressBar;}
protected:
Vec3r _Viewpoint;
real _bbox_diagonal; // diagonal of the current processed shape bbox
//oldtmp values
bool _computeViewIndependant;
real _meanK1;
real _meanKr;
real _minK1;
real _minKr;
real _maxK1;
real _maxKr;
unsigned _nPoints;
real _meanEdgeSize;
bool _orthographicProjection;
bool _computeRidgesAndValleys;
bool _computeSuggestiveContours;
bool _computeMaterialBoundaries;
bool _faceSmoothness;
bool _faceMarks;
real _sphereRadius; // expressed as a ratio of the mean edge size
real _creaseAngle; // [-1, 1] compared with the inner product of face normals
bool _changes;
real _kr_derivative_epsilon;
ProgressBar *_pProgressBar;
};
#endif // FEDGEDXETECTOR_H
|
