Eclipse SUMO - Simulation of Urban MObility
GUIPolygon.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
17 // The GUI-version of a polygon
18 /****************************************************************************/
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 #include <string>
26 #include <utils/geom/GeomHelper.h>
33 #include <utils/gui/div/GLHelper.h>
34 #include "GUIPolygon.h"
35 
36 //#define GUIPolygon_DEBUG_DRAW_VERTICES
37 
38 // ===========================================================================
39 // callbacks definitions
40 // ===========================================================================
41 
42 void APIENTRY beginCallback(GLenum which) {
43  glBegin(which);
44 }
45 
46 
47 void APIENTRY errorCallback(GLenum errorCode) {
48  const GLubyte* estring;
49 
50  estring = gluErrorString(errorCode);
51  fprintf(stderr, "Tessellation Error: %s\n", estring);
52  exit(0);
53 }
54 
55 
56 void APIENTRY endCallback(void) {
57  glEnd();
58 }
59 
60 
61 void APIENTRY vertexCallback(GLvoid* vertex) {
62  glVertex3dv((GLdouble*) vertex);
63 }
64 
65 
66 void APIENTRY combineCallback(GLdouble coords[3],
67  GLdouble* vertex_data[4],
68  GLfloat weight[4], GLdouble** dataOut) {
69  UNUSED_PARAMETER(weight);
70  UNUSED_PARAMETER(*vertex_data);
71  GLdouble* vertex;
72 
73  vertex = (GLdouble*) malloc(7 * sizeof(GLdouble));
74 
75  vertex[0] = coords[0];
76  vertex[1] = coords[1];
77  vertex[2] = coords[2];
78  *dataOut = vertex;
79 }
80 
81 GLfloat INV_POLY_TEX_DIM = 1.0 / 256.0;
82 GLfloat xPlane[] = {INV_POLY_TEX_DIM, 0.0, 0.0, 0.0};
83 GLfloat yPlane[] = {0.0, INV_POLY_TEX_DIM, 0.0, 0.0};
84 
85 // ===========================================================================
86 // method definitions
87 // ===========================================================================
88 
89 GUIPolygon::GUIPolygon(const std::string& id, const std::string& type,
90  const RGBColor& color, const PositionVector& shape, bool geo,
91  bool fill, double lineWidth, double layer, double angle, const std::string& imgFile,
92  bool relativePath):
93  SUMOPolygon(id, type, color, shape, geo, fill, lineWidth, layer, angle, imgFile, relativePath),
95  myDisplayList(0),
96  myRotatedShape(nullptr) {
97  if (angle != 0.) {
98  setShape(shape);
99  }
100 }
101 
102 
104  delete myRotatedShape;
105 }
106 
107 
108 
111  GUISUMOAbstractView& parent) {
112  GUIGLObjectPopupMenu* ret = new GUIGLObjectPopupMenu(app, parent, *this);
113  buildPopupHeader(ret, app, false);
114  FXString t(getShapeType().c_str());
115  new FXMenuCommand(ret, "(" + t + ")", nullptr, nullptr, 0);
116  new FXMenuSeparator(ret);
120  buildShowParamsPopupEntry(ret, false);
121  buildPositionCopyEntry(ret, false);
122  return ret;
123 }
124 
125 
130  new GUIParameterTableWindow(app, *this, 3 + (int)getParametersMap().size());
131  // add items
132  ret->mkItem("type", false, getShapeType());
133  ret->mkItem("layer", false, toString(getShapeLayer()));
134  ret->closeBuilding(this);
135  return ret;
136 }
137 
138 
139 Boundary
141  const PositionVector& shape = myRotatedShape != nullptr ? *myRotatedShape : myShape;
142  Boundary b;
143  b.add(shape.getBoxBoundary());
144  b.grow(2);
145  return b;
146 }
147 
148 
149 void
151  // first check if polygon can be drawn
152  if (checkDraw(s)) {
153  FXMutexLock locker(myLock);
154  //if (myDisplayList == 0 || (!getFill() && myLineWidth != s.polySize.getExaggeration(s))) {
155  // storeTesselation(s.polySize.getExaggeration(s));
156  //}
157  // push name (needed for getGUIGlObjectsUnderCursor(...)
158  glPushName(getGlID());
159  // draw inner polygon
160  drawInnerPolygon(s, false);
161  // pop name
162  glPopName();
163  }
164 }
165 
166 
167 void
169  FXMutexLock locker(myLock);
170  SUMOPolygon::setShape(shape);
171  if (getShapeNaviDegree() != 0.) {
172  if (myRotatedShape == nullptr) {
174  }
175  const Position& centroid = myShape.getCentroid();
177  myRotatedShape->sub(centroid);
179  myRotatedShape->add(centroid);
180  } else {
181  delete myRotatedShape;
182  myRotatedShape = nullptr;
183  }
184  //storeTesselation(myLineWidth);
185 }
186 
187 
188 void
189 GUIPolygon::performTesselation(double lineWidth) const {
190  const PositionVector& shape = myRotatedShape != nullptr ? *myRotatedShape : myShape;
191  if (getFill()) {
192  // draw the tesselated shape
193  double* points = new double[shape.size() * 3];
194  GLUtesselator* tobj = gluNewTess();
195  gluTessCallback(tobj, GLU_TESS_VERTEX, (GLvoid(APIENTRY*)()) &glVertex3dv);
196  gluTessCallback(tobj, GLU_TESS_BEGIN, (GLvoid(APIENTRY*)()) &beginCallback);
197  gluTessCallback(tobj, GLU_TESS_END, (GLvoid(APIENTRY*)()) &endCallback);
198  //gluTessCallback(tobj, GLU_TESS_ERROR, (GLvoid (APIENTRY*) ()) &errorCallback);
199  gluTessCallback(tobj, GLU_TESS_COMBINE, (GLvoid(APIENTRY*)()) &combineCallback);
200  gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
201  gluTessBeginPolygon(tobj, nullptr);
202  gluTessBeginContour(tobj);
203  for (int i = 0; i != (int)shape.size(); ++i) {
204  points[3 * i] = shape[(int) i].x();
205  points[3 * i + 1] = shape[(int) i].y();
206  points[3 * i + 2] = 0;
207  gluTessVertex(tobj, points + 3 * i, points + 3 * i);
208  }
209  gluTessEndContour(tobj);
210 
211  gluTessEndPolygon(tobj);
212  gluDeleteTess(tobj);
213  delete[] points;
214 
215  } else {
216  GLHelper::drawLine(shape);
217  GLHelper::drawBoxLines(shape, lineWidth);
218  }
219  //std::cout << "OpenGL says: '" << gluErrorString(glGetError()) << "'\n";
220 }
221 
222 
223 void
224 GUIPolygon::storeTesselation(double lineWidth) const {
225  if (myDisplayList > 0) {
226  glDeleteLists(myDisplayList, 1);
227  }
228  myDisplayList = glGenLists(1);
229  if (myDisplayList == 0) {
230  throw ProcessError("GUIPolygon::storeTesselation() could not create display list");
231  }
232  glNewList(myDisplayList, GL_COMPILE);
233  performTesselation(lineWidth);
234  glEndList();
235 }
236 
237 
238 void
239 GUIPolygon::setColor(const GUIVisualizationSettings& s, bool disableSelectionColor) const {
240  const GUIColorer& c = s.polyColorer;
241  const int active = c.getActive();
242  if (s.netedit && active != 1 && gSelected.isSelected(GLO_POLYGON, getGlID()) && disableSelectionColor) {
243  // override with special selection colors (unless the color scheme is based on selection)
244  GLHelper::setColor(RGBColor(0, 0, 204));
245  } else if (active == 0) {
247  } else if (active == 1) {
249  } else {
251  }
252 }
253 
254 
255 bool
257  if (s.polySize.getExaggeration(s, this) == 0) {
258  return false;
259  }
260  Boundary boundary = myShape.getBoxBoundary();
261  if (s.scale * MAX2(boundary.getWidth(), boundary.getHeight()) < s.polySize.minSize) {
262  return false;
263  }
264  if (getFill()) {
265  if (myShape.size() < 3) {
266  return false;
267  }
268  } else {
269  if (myShape.size() < 2) {
270  return false;
271  }
272  }
273  return true;
274 }
275 
276 
277 void
278 GUIPolygon::drawInnerPolygon(const GUIVisualizationSettings& s, bool disableSelectionColor) const {
279  glPushMatrix();
280  glTranslated(0, 0, getShapeLayer());
281  setColor(s, disableSelectionColor);
282 
283  int textureID = -1;
284  if (getFill()) {
285  const std::string& file = getShapeImgFile();
286  if (file != "") {
287  textureID = GUITexturesHelper::getTextureID(file, true);
288  }
289  }
290  // init generation of texture coordinates
291  if (textureID >= 0) {
292  glEnable(GL_TEXTURE_2D);
293  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
294  glDisable(GL_CULL_FACE);
295  glDisable(GL_DEPTH_TEST); // without DEPTH_TEST vehicles may be drawn below roads
296  glDisable(GL_LIGHTING);
297  glDisable(GL_COLOR_MATERIAL);
298  glDisable(GL_ALPHA_TEST);
299  glEnable(GL_BLEND);
300  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
301  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
302  glBindTexture(GL_TEXTURE_2D, textureID);
303  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
304  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
305  // http://www.gamedev.net/topic/133564-glutesselation-and-texture-mapping/
306  glEnable(GL_TEXTURE_GEN_S);
307  glEnable(GL_TEXTURE_GEN_T);
308  glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
309  glTexGenfv(GL_S, GL_OBJECT_PLANE, xPlane);
310  glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
311  glTexGenfv(GL_T, GL_OBJECT_PLANE, yPlane);
312  }
313  // recall tesselation
314  //glCallList(myDisplayList);
316  // de-init generation of texture coordinates
317  if (textureID >= 0) {
318  glEnable(GL_DEPTH_TEST);
319  glBindTexture(GL_TEXTURE_2D, 0);
320  glDisable(GL_TEXTURE_2D);
321  glDisable(GL_TEXTURE_GEN_S);
322  glDisable(GL_TEXTURE_GEN_T);
323  }
324  const PositionVector& shape = myRotatedShape != nullptr ? *myRotatedShape : myShape;
325 #ifdef GUIPolygon_DEBUG_DRAW_VERTICES
326  GLHelper::debugVertices(shape, 80 / s.scale);
327 #endif
328  glPopMatrix();
329  const Position& namePos = shape.getPolygonCenter();
330  drawName(namePos, s.scale, s.polyName, s.angle);
331  if (s.polyType.show) {
332  const Position p = namePos + Position(0, -0.6 * s.polyType.size / s.scale);
334  }
335 }
336 
337 
338 /****************************************************************************/
GLHelper::debugVertices
static void debugVertices(const PositionVector &shape, double size, double layer=256)
draw vertex numbers for the given shape (in a random color)
Definition: GLHelper.cpp:808
GUIVisualizationSettings::polySize
GUIVisualizationSizeSettings polySize
Definition: GUIVisualizationSettings.h:616
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:31
GUIGlObject.h
GLHelper::drawTextSettings
static void drawTextSettings(const GUIVisualizationTextSettings &settings, const std::string &text, const Position &pos, const double scale, const double angle=0, const double layer=2048)
Definition: GLHelper.cpp:706
GUIParameterTableWindow
A window containing a gl-object's parameter.
Definition: GUIParameterTableWindow.h:62
PositionVector::getPolygonCenter
Position getPolygonCenter() const
Returns the arithmetic of all corner points.
Definition: PositionVector.cpp:400
INV_POLY_TEX_DIM
GLfloat INV_POLY_TEX_DIM
Definition: GUIPolygon.cpp:81
beginCallback
void APIENTRY beginCallback(GLenum which)
Definition: GUIPolygon.cpp:42
GUISUMOAbstractView
Definition: GUISUMOAbstractView.h:72
GUIParameterTableWindow.h
GUIGlObject::drawName
void drawName(const Position &pos, const double scale, const GUIVisualizationTextSettings &settings, const double angle=0) const
draw name of item
Definition: GUIGlObject.cpp:354
Shape::getShapeNaviDegree
double getShapeNaviDegree() const
Returns the angle of the Shape in navigational degrees.
Definition: Shape.h:96
GUIVisualizationSettings::angle
double angle
The current view rotation angle.
Definition: GUIVisualizationSettings.h:405
endCallback
void APIENTRY endCallback(void)
Definition: GUIPolygon.cpp:56
GUIGlObject::buildSelectionPopupEntry
void buildSelectionPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to (de)select the object.
Definition: GUIGlObject.cpp:235
GLHelper::drawBoxLines
static void drawBoxLines(const PositionVector &geom, const std::vector< double > &rots, const std::vector< double > &lengths, double width, int cornerDetail=0, double offset=0)
Draws thick lines.
Definition: GLHelper.cpp:182
PositionVector::rotate2D
void rotate2D(double angle)
Definition: PositionVector.cpp:1503
GUIPolygon.h
SUMOPolygon::setShape
virtual void setShape(const PositionVector &shape)
Sets the shape of the polygon.
Definition: SUMOPolygon.h:120
GUIGLObjectPopupMenu.h
GUIGlobalSelection.h
GUIVisualizationSettings::netedit
bool netedit
Whether the settings are for Netedit.
Definition: GUIVisualizationSettings.h:402
Boundary::getHeight
double getHeight() const
Returns the height of the boundary (y-axis)
Definition: Boundary.cpp:160
Shape::getShapeImgFile
const std::string & getShapeImgFile() const
Returns the imgFile of the Shape.
Definition: Shape.h:103
GUIVisualizationSettings.h
GLHelper.h
GUIGlObject_AbstractAdd
Definition: GUIGlObject_AbstractAdd.h:39
SUMOPolygon::myShape
PositionVector myShape
The positions of the polygon.
Definition: SUMOPolygon.h:132
PositionVector
A list of positions.
Definition: PositionVector.h:45
GUIGLObjectPopupMenu
The popup menu of a globject.
Definition: GUIGLObjectPopupMenu.h:47
xPlane
GLfloat xPlane[]
Definition: GUIPolygon.cpp:82
GUIPolygon::setColor
void setColor(const GUIVisualizationSettings &s, bool disableSelectionColor) const
set color
Definition: GUIPolygon.cpp:239
SUMOPolygon::myLineWidth
double myLineWidth
The line width for drawing an unfilled polygon.
Definition: SUMOPolygon.h:141
GUIVisualizationSettings::polyName
GUIVisualizationTextSettings polyName
Definition: GUIVisualizationSettings.h:619
GLHelper::setColor
static void setColor(const RGBColor &c)
Sets the gl-color to this value.
Definition: GLHelper.cpp:621
PositionVector::getBoxBoundary
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
Definition: PositionVector.cpp:390
GUIVisualizationSettings::polyColorer
GUIColorer polyColorer
The polygon colorer.
Definition: GUIVisualizationSettings.h:613
Shape::getShapeColor
const RGBColor & getShapeColor() const
Returns the color of the Shape.
Definition: Shape.h:82
GUIParameterTableWindow::closeBuilding
void closeBuilding(const Parameterised *p=0)
Closes the building of the table.
Definition: GUIParameterTableWindow.cpp:219
GLO_POLYGON
@ GLO_POLYGON
a polygon
Definition: GUIGlObjectTypes.h:104
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:79
PositionVector::add
void add(double xoff, double yoff, double zoff)
Definition: PositionVector.cpp:617
GUIPolygon::drawInnerPolygon
void drawInnerPolygon(const GUIVisualizationSettings &s, bool disableSelectionColor) const
draw inner Polygon (before pushName() )
Definition: GUIPolygon.cpp:278
GUIVisualizationSettings::polyType
GUIVisualizationTextSettings polyType
Definition: GUIVisualizationSettings.h:622
RGBColor
Definition: RGBColor.h:39
Parameterised::getParametersMap
const std::map< std::string, std::string > & getParametersMap() const
Returns the inner key/value map.
Definition: Parameterised.cpp:106
GUIPolygon::myRotatedShape
PositionVector * myRotatedShape
shape rotated on the centroid, if rotation is needed, nullptr otherwise
Definition: GUIPolygon.h:136
GUIPolygon::~GUIPolygon
~GUIPolygon()
Destructor.
Definition: GUIPolygon.cpp:103
combineCallback
void APIENTRY combineCallback(GLdouble coords[3], GLdouble *vertex_data[4], GLfloat weight[4], GLdouble **dataOut)
Definition: GUIPolygon.cpp:66
Shape::getShapeLayer
double getShapeLayer() const
Returns the layer of the Shape.
Definition: Shape.h:89
GUIGlObject::buildNameCopyPopupEntry
void buildNameCopyPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds entries which allow to copy the name / typed name into the clipboard.
Definition: GUIGlObject.cpp:225
GUIPropertySchemeStorage::getScheme
T & getScheme()
Definition: GUIPropertySchemeStorage.h:79
GUIParameterTableWindow::mkItem
void mkItem(const char *name, bool dynamic, ValueSource< T > *src)
Adds a row which obtains its value from a ValueSource.
Definition: GUIParameterTableWindow.h:108
GUIPolygon::setShape
virtual void setShape(const PositionVector &shape)
set a new shape and update the tesselation
Definition: GUIPolygon.cpp:168
GUITexturesHelper.h
GUIGlObject::getGlID
GUIGlID getGlID() const
Returns the numerical id of the object.
Definition: GUIGlObject.cpp:149
PositionVector::sub
void sub(double xoff, double yoff, double zoff)
Definition: PositionVector.cpp:631
Boundary
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:41
GUIPolygon::getPopUpMenu
GUIGLObjectPopupMenu * getPopUpMenu(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own popup-menu.
Definition: GUIPolygon.cpp:110
Boundary::getWidth
double getWidth() const
Returns the width of the boudary (x-axis)
Definition: Boundary.cpp:154
GUIVisualizationSettings::scale
double scale
information about a lane's width (temporary, used for a single view)
Definition: GUIVisualizationSettings.h:632
ProcessError
Definition: UtilExceptions.h:39
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
Boundary::add
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
Definition: Boundary.cpp:78
GLHelper::drawLine
static void drawLine(const Position &beg, double rot, double visLength)
Draws a thin line.
Definition: GLHelper.cpp:274
GUIPolygon::getParameterWindow
GUIParameterTableWindow * getParameterWindow(GUIMainWindow &app, GUISUMOAbstractView &parent)
Returns an own parameter window.
Definition: GUIPolygon.cpp:127
Shape::getShapeType
const std::string & getShapeType() const
Returns the (abstract) type of the Shape.
Definition: Shape.h:75
GUIVisualizationTextSettings::show
bool show
flag show
Definition: GUIVisualizationSettings.h:68
errorCallback
void APIENTRY errorCallback(GLenum errorCode)
Definition: GUIPolygon.cpp:47
GUIVisualizationSizeSettings::minSize
double minSize
The minimum size to draw this object.
Definition: GUIVisualizationSettings.h:103
vertexCallback
void APIENTRY vertexCallback(GLvoid *vertex)
Definition: GUIPolygon.cpp:61
DEG2RAD
#define DEG2RAD(x)
Definition: GeomHelper.h:37
GUIGlObject::buildPopupHeader
void buildPopupHeader(GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true)
Builds the header.
Definition: GUIGlObject.cpp:207
GUIPolygon::performTesselation
void performTesselation(double lineWidth) const
Definition: GUIPolygon.cpp:189
SUMOPolygon
Definition: SUMOPolygon.h:46
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
GUIPolygon::getCenteringBoundary
Boundary getCenteringBoundary() const
Returns the boundary to which the view shall be centered in order to show the object.
Definition: GUIPolygon.cpp:140
yPlane
GLfloat yPlane[]
Definition: GUIPolygon.cpp:83
GUIMainWindow
Definition: GUIMainWindow.h:46
GUIPolygon::drawGL
virtual void drawGL(const GUIVisualizationSettings &s) const
Draws the object.
Definition: GUIPolygon.cpp:150
GUIGlObject::buildShowParamsPopupEntry
void buildShowParamsPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to open the parameter window.
Definition: GUIGlObject.cpp:248
gSelected
GUISelectedStorage gSelected
A global holder of selected objects.
Definition: GUIGlobalSelection.cpp:33
GUIGlObject::buildCenterPopupEntry
void buildCenterPopupEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to center to the object.
Definition: GUIGlObject.cpp:216
GUIGlObject::buildPositionCopyEntry
void buildPositionCopyEntry(GUIGLObjectPopupMenu *ret, bool addSeparator=true)
Builds an entry which allows to copy the cursor position if geo projection is used,...
Definition: GUIGlObject.cpp:266
PositionVector::getCentroid
Position getCentroid() const
Returns the centroid (closes the polygon if unclosed)
Definition: PositionVector.cpp:414
GUIVisualizationTextSettings::size
double size
text size
Definition: GUIVisualizationSettings.h:71
GUIPolygon::GUIPolygon
GUIPolygon(const std::string &id, const std::string &type, const RGBColor &color, const PositionVector &shape, bool geo, bool fill, double lineWidth, double layer=0, double angle=0, const std::string &imgFile="", bool relativePath=false)
Constructor.
Definition: GUIPolygon.cpp:89
config.h
GeomHelper.h
Boundary::grow
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:300
SUMOPolygon::getFill
bool getFill() const
Returns whether the polygon is filled.
Definition: SUMOPolygon.h:89
GUIPolygon::myLock
FXMutex myLock
The mutex used to avoid concurrent updates of the shape.
Definition: GUIPolygon.h:130
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition: GUIVisualizationSettings.h:345
GUIPolygon::myDisplayList
GLuint myDisplayList
id of the display list for the cached tesselation
Definition: GUIPolygon.h:133
GUIPolygon::checkDraw
bool checkDraw(const GUIVisualizationSettings &s) const
check if Polygon can be drawn
Definition: GUIPolygon.cpp:256
GUITexturesHelper::getTextureID
static int getTextureID(const std::string &filename, const bool mirrorX=false)
return texture id for the given filename (initialize on first use)
Definition: GUITexturesHelper.cpp:112
GUIPropertyScheme::getColor
const T getColor(const double value) const
Definition: GUIPropertyScheme.h:110
GUIPropertySchemeStorage::getActive
int getActive() const
Definition: GUIPropertySchemeStorage.h:75
GUIVisualizationSizeSettings::getExaggeration
double getExaggeration(const GUIVisualizationSettings &s, const GUIGlObject *o, double factor=20) const
return the drawing size including exaggeration and constantSize values
Definition: GUIVisualizationSettings.cpp:212
GUIPropertySchemeStorage< GUIColorScheme >
GUIPolygon::storeTesselation
void storeTesselation(double lineWidth) const
store the drawing commands in a display list
Definition: GUIPolygon.cpp:224
GUISelectedStorage::isSelected
bool isSelected(GUIGlObjectType type, GUIGlID id)
Returns the information whether the object with the given type and id is selected.
Definition: GUISelectedStorage.cpp:94