SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GUIVehicle.cpp
Go to the documentation of this file.
1 /****************************************************************************/
9 // A MSVehicle extended by some values for usage within the gui
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
12 // Copyright (C) 2001-2012 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #ifdef _MSC_VER
28 #include <windows_config.h>
29 #else
30 #include <config.h>
31 #endif
32 
33 #ifdef WIN32
34 #include <windows.h>
35 #endif
36 
37 #include <GL/gl.h>
38 
39 #include <cmath>
40 #include <vector>
41 #include <string>
49 #include <utils/gui/div/GLHelper.h>
51 #include <microsim/MSVehicle.h>
58 #include <gui/GUIGlobals.h>
59 #include "GUIVehicle.h"
60 #include "GUINet.h"
61 #include "GUIEdge.h"
62 
63 
64 #ifdef CHECK_MEMORY_LEAKS
65 #include <foreign/nvwa/debug_new.h>
66 #endif // CHECK_MEMORY_LEAKS
67 
68 
69 // ===========================================================================
70 // FOX callback mapping
71 // ===========================================================================
72 FXDEFMAP(GUIVehicle::GUIVehiclePopupMenu) GUIVehiclePopupMenuMap[] = {
83 };
84 
85 // Object implementation
86 FXIMPLEMENT(GUIVehicle::GUIVehiclePopupMenu, GUIGLObjectPopupMenu, GUIVehiclePopupMenuMap, ARRAYNUMBER(GUIVehiclePopupMenuMap))
87 
88 
89 
90 // ===========================================================================
91 // data definitions
92 // ===========================================================================
93 /* -------------------------------------------------------------------------
94  * drawed shapes
95  * ----------------------------------------------------------------------- */
96 double vehiclePoly_PassengerCarBody[] = { .5, 0, 0, 0, 0, .3, 0.08, .44, 0.25, .5, 0.95, .5, 1., .4, 1., -.4, 0.95, -.5, 0.25, -.5, 0.08, -.44, 0, -.3, 0, 0, -10000 };
97 double vehiclePoly_PassengerCarBodyFront[] = { 0.1, 0, 0.025, 0, 0.025, 0.25, 0.27, 0.4, 0.27, -.4, 0.025, -0.25, 0.025, 0, -10000 };
98 double vehiclePoly_PassengerFrontGlass[] = { 0.35, 0, 0.3, 0, 0.3, 0.4, 0.43, 0.3, 0.43, -0.3, 0.3, -0.4, 0.3, 0, -10000 };
99 double vehiclePoly_PassengerSedanRightGlass[] = { 0.36, -.43, 0.34, -.47, 0.77, -.47, 0.67, -.37, 0.45, -.37, 0.34, -.47, -10000 };
100 double vehiclePoly_PassengerSedanLeftGlass[] = { 0.36, .43, 0.34, .47, 0.77, .47, 0.67, .37, 0.45, .37, 0.34, .47, -10000 };
101 double vehiclePoly_PassengerSedanBackGlass[] = { 0.80, 0, 0.70, 0, 0.70, 0.3, 0.83, 0.4, 0.83, -.4, 0.70, -.3, 0.70, 0, -10000 };
102 double vehiclePoly_PassengerHatchbackRightGlass[] = { 0.36, -.43, 0.34, -.47, 0.94, -.47, 0.80, -.37, 0.45, -.37, 0.34, -.47, -10000 };
103 double vehiclePoly_PassengerHatchbackLeftGlass[] = { 0.36, .43, 0.34, .47, 0.94, .47, 0.80, .37, 0.45, .37, 0.34, .47, -10000 };
104 double vehiclePoly_PassengerHatchbackBackGlass[] = { 0.92, 0, 0.80, 0, 0.80, 0.3, 0.95, 0.4, 0.95, -.4, 0.80, -.3, 0.80, 0, -10000 };
105 double vehiclePoly_PassengerWagonRightGlass[] = { 0.36, -.43, 0.34, -.47, 0.94, -.47, 0.87, -.37, 0.45, -.37, 0.34, -.47, -10000 };
106 double vehiclePoly_PassengerWagonLeftGlass[] = { 0.36, .43, 0.34, .47, 0.94, .47, 0.87, .37, 0.45, .37, 0.34, .47, -10000 };
107 double vehiclePoly_PassengerWagonBackGlass[] = { 0.92, 0, 0.90, 0, 0.90, 0.3, 0.95, 0.4, 0.95, -.4, 0.90, -.3, 0.90, 0, -10000 };
108 
109 double vehiclePoly_PassengerVanBody[] = { .5, 0, 0, 0, 0, .4, 0.1, .5, 0.97, .5, 1., .47, 1., -.47, 0.97, -.5, 0.1, -.5, 0, -.4, 0, 0, -10000 };
110 double vehiclePoly_PassengerVanBodyFront[] = { 0.1, 0, 0.025, 0, 0.025, 0.25, 0.13, 0.4, 0.13, -.4, 0.025, -0.25, 0.025, 0, -10000 };
111 double vehiclePoly_PassengerVanFrontGlass[] = { 0.21, 0, 0.16, 0, 0.16, 0.4, 0.29, 0.3, 0.29, -0.3, 0.16, -0.4, 0.16, 0, -10000 };
112 double vehiclePoly_PassengerVanRightGlass[] = { 0.36, -.43, 0.20, -.47, 0.98, -.47, 0.91, -.37, 0.31, -.37, 0.20, -.47, -10000 };
113 double vehiclePoly_PassengerVanLeftGlass[] = { 0.36, .43, 0.20, .47, 0.98, .47, 0.91, .37, 0.31, .37, 0.20, .47, -10000 };
114 double vehiclePoly_PassengerVanBackGlass[] = { 0.95, 0, 0.94, 0, 0.94, 0.3, 0.98, 0.4, 0.98, -.4, 0.94, -.3, 0.94, 0, -10000 };
115 
116 double vehiclePoly_DeliveryMediumRightGlass[] = { 0.21, -.43, 0.20, -.47, 0.38, -.47, 0.38, -.37, 0.31, -.37, 0.20, -.47, -10000 };
117 double vehiclePoly_DeliveryMediumLeftGlass[] = { 0.21, .43, 0.20, .47, 0.38, .47, 0.38, .37, 0.31, .37, 0.20, .47, -10000 };
118 
119 double vehiclePoly_TransportBody[] = { .5, 0, 0, 0, 0, .45, 0.05, .5, 2.25, .5, 2.25, -.5, 0.05, -.5, 0, -.45, 0, 0, -10000 };
120 double vehiclePoly_TransportFrontGlass[] = { 0.1, 0, 0.05, 0, 0.05, 0.45, 0.25, 0.4, 0.25, -.4, 0.05, -0.45, 0.05, 0, -10000 };
121 double vehiclePoly_TransportRightGlass[] = { 0.36, -.47, 0.10, -.48, 1.25, -.48, 1.25, -.4, 0.3, -.4, 0.10, -.48, -10000 };
122 double vehiclePoly_TransportLeftGlass[] = { 0.36, .47, 0.10, .48, 1.25, .48, 1.25, .4, 0.3, .4, 0.10, .48, -10000 };
123 
124 double vehiclePoly_EVehicleBody[] = { .5, 0, 0, 0, 0, .3, 0.08, .44, 0.25, .5, 0.75, .5, .92, .44, 1, .3, 1, -.3, .92, -.44, .75, -.5, .25, -.5, 0.08, -.44, 0, -.3, 0, 0, -1000 };
125 double vehiclePoly_EVehicleFrontGlass[] = { .5, 0, 0.05, .05, 0.05, .25, 0.13, .39, 0.3, .45, 0.70, .45, .87, .39, .95, .25, .95, -.25, .87, -.39, .70, -.45, .3, -.45, 0.13, -.39, 0.05, -.25, 0.05, 0.05, -1000 };
126 //double vehiclePoly_EVehicleFrontGlass[] = { 0.35,0, 0.1,0, 0.1,0.4, 0.43,0.3, 0.43,-0.3, 0.1,-0.4, 0.1,0, -10000 };
127 double vehiclePoly_EVehicleBackGlass[] = { 0.65, 0, 0.9, 0, 0.9, 0.4, 0.57, 0.3, 0.57, -0.3, 0.9, -0.4, 0.9, 0, -10000 };
128 
129 
130 // ===========================================================================
131 // method definitions
132 // ===========================================================================
133 /* -------------------------------------------------------------------------
134  * GUIVehicle::GUIVehiclePopupMenu - methods
135  * ----------------------------------------------------------------------- */
137  GUIMainWindow& app, GUISUMOAbstractView& parent,
138  GUIGlObject& o, std::map<GUISUMOAbstractView*, int> &additionalVisualizations)
139  : GUIGLObjectPopupMenu(app, parent, o), myVehiclesAdditionalVisualizations(additionalVisualizations) {
140 }
141 
142 
144 
145 
146 long
148  assert(myObject->getType() == GLO_VEHICLE);
149  if (!static_cast<GUIVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_ALL_ROUTES)) {
150  static_cast<GUIVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_ALL_ROUTES);
151  }
152  return 1;
153 }
154 
155 long
157  assert(myObject->getType() == GLO_VEHICLE);
158  static_cast<GUIVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_ALL_ROUTES);
159  return 1;
160 }
161 
162 
163 long
165  assert(myObject->getType() == GLO_VEHICLE);
166  if (!static_cast<GUIVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_ROUTE)) {
167  static_cast<GUIVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_ROUTE);
168  }
169  return 1;
170 }
171 
172 long
174  assert(myObject->getType() == GLO_VEHICLE);
175  static_cast<GUIVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_ROUTE);
176  return 1;
177 }
178 
179 
180 long
182  assert(myObject->getType() == GLO_VEHICLE);
183  if (!static_cast<GUIVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_BEST_LANES)) {
184  static_cast<GUIVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_BEST_LANES);
185  }
186  return 1;
187 }
188 
189 long
191  assert(myObject->getType() == GLO_VEHICLE);
192  static_cast<GUIVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_BEST_LANES);
193  return 1;
194 }
195 
196 
197 long
199  assert(myObject->getType() == GLO_VEHICLE);
200  if (!static_cast<GUIVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_TRACKED)) {
201  myParent->startTrack(static_cast<GUIVehicle*>(myObject)->getGlID());
202  static_cast<GUIVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_TRACKED);
203  }
204  return 1;
205 }
206 
207 long
209  assert(myObject->getType() == GLO_VEHICLE);
210  static_cast<GUIVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_TRACKED);
211  myParent->stopTrack();
212  return 1;
213 }
214 
215 
216 long
218  assert(myObject->getType() == GLO_VEHICLE);
219  if (!static_cast<GUIVehicle*>(myObject)->hasActiveAddVisualisation(myParent, VO_SHOW_LFLINKITEMS)) {
220  static_cast<GUIVehicle*>(myObject)->addActiveAddVisualisation(myParent, VO_SHOW_LFLINKITEMS);
221  }
222  return 1;
223 }
224 
225 long
227  assert(myObject->getType() == GLO_VEHICLE);
228  static_cast<GUIVehicle*>(myObject)->removeActiveAddVisualisation(myParent, VO_SHOW_LFLINKITEMS);
229  return 1;
230 }
231 
232 
233 /* -------------------------------------------------------------------------
234  * GUIVehicle - methods
235  * ----------------------------------------------------------------------- */
237  const MSVehicleType* type,
238  int vehicleIndex)
239  : MSVehicle(pars, route, type, vehicleIndex),
240  GUIGlObject(GLO_VEHICLE, pars->id) {
241  // as it is possible to show all vehicle routes, we have to store them... (bug [ 2519761 ])
243  myMoveReminders.push_back(std::make_pair(myRoutes, 0.));
244 }
245 
246 
248  myLock.lock();
249  for (std::map<GUISUMOAbstractView*, int>::iterator i = myAdditionalVisualizations.begin(); i != myAdditionalVisualizations.end(); ++i) {
250  while (i->first->removeAdditionalGLVisualisation(this));
251  }
252  myLock.unlock();
254  delete myRoutes;
255 }
256 
257 
260  GUISUMOAbstractView& parent) {
262  buildPopupHeader(ret, app);
266  //
268  new FXMenuCommand(ret, "Hide Current Route", 0, ret, MID_HIDE_CURRENTROUTE);
269  } else {
270  new FXMenuCommand(ret, "Show Current Route", 0, ret, MID_SHOW_CURRENTROUTE);
271  }
273  new FXMenuCommand(ret, "Hide All Routes", 0, ret, MID_HIDE_ALLROUTES);
274  } else {
275  new FXMenuCommand(ret, "Show All Routes", 0, ret, MID_SHOW_ALLROUTES);
276  }
278  new FXMenuCommand(ret, "Hide Best Lanes", 0, ret, MID_HIDE_BEST_LANES);
279  } else {
280  new FXMenuCommand(ret, "Show Best Lanes", 0, ret, MID_SHOW_BEST_LANES);
281  }
283  new FXMenuCommand(ret, "Hide Link Items", 0, ret, MID_HIDE_LFLINKITEMS);
284  } else {
285  new FXMenuCommand(ret, "Show Link Items", 0, ret, MID_SHOW_LFLINKITEMS);
286  }
287  new FXMenuSeparator(ret);
288  int trackedID = parent.getTrackedID();
289  if (trackedID < 0 || (size_t)trackedID != getGlID()) {
290  new FXMenuCommand(ret, "Start Tracking", 0, ret, MID_START_TRACK);
291  } else {
292  new FXMenuCommand(ret, "Stop Tracking", 0, ret, MID_STOP_TRACK);
293  }
294  new FXMenuSeparator(ret);
295  //
297  buildPositionCopyEntry(ret, false);
298  return ret;
299 }
300 
301 
306  new GUIParameterTableWindow(app, *this, 15);
307  // add items
308  ret->mkItem("type [NAME]", false, myType->getID());
309  if (getParameter().repetitionNumber > 0) {
310  ret->mkItem("left same route [#]", false, (unsigned int) getParameter().repetitionNumber);
311  }
312  if (getParameter().repetitionOffset > 0) {
313  ret->mkItem("insertion period [s]", false, time2string(getParameter().repetitionOffset));
314  }
315  ret->mkItem("waiting time [s]", true,
317  ret->mkItem("last lane change [s]", true,
319  ret->mkItem("desired depart [s]", false, time2string(getParameter().depart));
320  ret->mkItem("position [m]", true,
322  ret->mkItem("speed [m/s]", true,
324  ret->mkItem("angle", true,
326  ret->mkItem("CO2 (HBEFA) [g/s]", true,
328  ret->mkItem("CO (HBEFA) [g/s]", true,
330  ret->mkItem("HC (HBEFA) [g/s]", true,
332  ret->mkItem("NOx (HBEFA) [g/s]", true,
334  ret->mkItem("PMx (HBEFA) [g/s]", true,
336  ret->mkItem("fuel (HBEFA) [l/s]", true,
338  ret->mkItem("noise (Harmonoise) [dB]", true,
340  // close building
341  ret->closeBuilding();
342  return ret;
343 }
344 
345 
346 Boundary
348  Boundary b;
349  b.add(getPosition());
350  b.grow(20);
351  return b;
352 }
353 
354 
355 inline void
357  glPushMatrix();
358  glScaled(veh.getVehicleType().getWidth(), veh.getVehicleType().getLength(), 1.);
359  glBegin(GL_TRIANGLE_STRIP);
360  glVertex2d(0., 0.);
361  glVertex2d(-.5, .15);
362  glVertex2d( .5, .15);
363  glVertex2d(-.5, 1.);
364  glVertex2d( .5, 1.);
365  glEnd();
366  glPopMatrix();
367 }
368 
369 
370 inline void
372  const SUMOReal length = veh.getVehicleType().getLength();
373  if (length >= 8.) {
375  return;
376  }
377  glPushMatrix();
378  glScaled(veh.getVehicleType().getWidth(), length, 1.);
379  glBegin(GL_TRIANGLES);
380  glVertex2d(0., 0.);
381  glVertex2d(-.5, 1.);
382  glVertex2d( .5, 1.);
383  glEnd();
384  glPopMatrix();
385 }
386 
387 
388 void
389 drawPoly(double* poses, SUMOReal offset) {
390  glPushMatrix();
391  glTranslated(0, 0, offset * .1);
392  glPolygonOffset(0, offset * -1);
393  glBegin(GL_TRIANGLE_FAN);
394  int i = 0;
395  while (poses[i] > -999) {
396  glVertex2d(poses[i], poses[i + 1]);
397  i = i + 2;
398  }
399  glEnd();
400  glPopMatrix();
401 }
402 
403 
404 inline void
406  RGBColor current = GLHelper::getColor();
407  RGBColor lighter = current.changedBrightness(.2);
408  RGBColor darker = current.changedBrightness(-.2);
409 
410  SUMOReal length = veh.getVehicleType().getLength();
411  glPushMatrix();
412  glRotated(90, 0, 0, 1);
413  glScaled(length, veh.getVehicleType().getWidth(), 1.);
415 
416  // draw main body
417  switch (shape) {
418  case SVS_UNKNOWN:
420  GLHelper::setColor(lighter);
421  drawPoly(vehiclePoly_PassengerCarBodyFront, 4.5);
422  glColor3d(0, 0, 0);
423  drawPoly(vehiclePoly_PassengerFrontGlass, 4.5);
424  break;
425  case SVS_PEDESTRIAN:
426  //glScaled(1./(lenght)), 1, 1.);
427  glTranslated(0, 0, .045);
429  glTranslated(0, 0, -.045);
430  glScaled(.7, 2, 1);
431  glTranslated(0, 0, .04);
432  GLHelper::setColor(lighter);
434  glTranslated(0, 0, -.04);
435  break;
436  case SVS_BICYCLE:
437  case SVS_MOTORCYCLE: {
438  glPushMatrix();
439  glTranslated(.5, 0, 0);
440  glScaled(.25 / (length), 1, 1.);
441  glTranslated(0, 0, .045);
443  glScaled(.7, 2, 1);
444  glTranslated(0, 0, -.045);
445  glTranslated(0, 0, .04);
446  GLHelper::setColor(lighter);
448  glTranslated(0, 0, -.04);
449  glPopMatrix();
450  }
451  break;
452  case SVS_PASSENGER:
453  case SVS_PASSENGER_SEDAN:
455  case SVS_PASSENGER_WAGON:
457  GLHelper::setColor(lighter);
458  drawPoly(vehiclePoly_PassengerCarBodyFront, 4.5);
459  glColor3d(0, 0, 0);
460  drawPoly(vehiclePoly_PassengerFrontGlass, 4.5);
461  break;
462  case SVS_PASSENGER_VAN:
463  drawPoly(vehiclePoly_PassengerVanBody, 4);
464  GLHelper::setColor(lighter);
465  drawPoly(vehiclePoly_PassengerVanBodyFront, 4.5);
466  glColor3d(0, 0, 0);
467  drawPoly(vehiclePoly_PassengerVanFrontGlass, 4.5);
468  drawPoly(vehiclePoly_PassengerVanRightGlass, 4.5);
469  drawPoly(vehiclePoly_PassengerVanLeftGlass, 4.5);
470  drawPoly(vehiclePoly_PassengerVanBackGlass, 4.5);
471  break;
472  case SVS_DELIVERY:
473  drawPoly(vehiclePoly_PassengerVanBody, 4);
474  GLHelper::setColor(lighter);
475  drawPoly(vehiclePoly_PassengerVanBodyFront, 4.5);
476  glColor3d(0, 0, 0);
477  drawPoly(vehiclePoly_PassengerVanFrontGlass, 4.5);
478  drawPoly(vehiclePoly_DeliveryMediumRightGlass, 4.5);
479  drawPoly(vehiclePoly_DeliveryMediumLeftGlass, 4.5);
480  break;
481  case SVS_TRANSPORT:
484  glScaled(1. / (length), 1, 1.);
485  drawPoly(vehiclePoly_TransportBody, 4);
486  glColor3d(0, 0, 0);
487  drawPoly(vehiclePoly_TransportFrontGlass, 4.5);
488  drawPoly(vehiclePoly_TransportRightGlass, 4.5);
489  drawPoly(vehiclePoly_TransportLeftGlass, 4.5);
490  break;
491  case SVS_BUS:
492  case SVS_BUS_TROLLEY:
494  case SVS_BUS_CITY: {
495  SUMOReal ml = length;
496  glScaled(1. / (length), 1, 1.);
497  glTranslated(0, 0, .04);
498  glBegin(GL_TRIANGLE_FAN);
499  glVertex2d(ml / 2., 0);
500  glVertex2d(0, 0);
501  glVertex2d(0, -.45);
502  glVertex2d(0 + .05, -.5);
503  glVertex2d(ml - .05, -.5);
504  glVertex2d(ml, -.45);
505  glVertex2d(ml, .45);
506  glVertex2d(ml - .05, .5);
507  glVertex2d(0 + .05, .5);
508  glVertex2d(0, .45);
509  glVertex2d(0, 0);
510  glEnd();
511  glTranslated(0, 0, -.04);
512 
513  glTranslated(0, 0, .045);
514  glColor3d(0, 0, 0);
515  glBegin(GL_QUADS);
516  glVertex2d(0 + .05, .48);
517  glVertex2d(0 + .05, -.48);
518  glVertex2d(0 + .15, -.48);
519  glVertex2d(0 + .15, .48);
520 
521  glVertex2d(ml - .1, .45);
522  glVertex2d(ml - .1, -.45);
523  glVertex2d(ml - .05, -.45);
524  glVertex2d(ml - .05, .45);
525 
526  glVertex2d(0 + .20, .49);
527  glVertex2d(0 + .20, .45);
528  glVertex2d(ml - .20, .45);
529  glVertex2d(ml - .20, .49);
530 
531  glVertex2d(0 + .20, -.49);
532  glVertex2d(0 + .20, -.45);
533  glVertex2d(ml - .20, -.45);
534  glVertex2d(ml - .20, -.49);
535 
536  glEnd();
537  glTranslated(0, 0, -.045);
538  }
539  break;
540  case SVS_BUS_OVERLAND:
541  case SVS_RAIL:
542  case SVS_RAIL_LIGHT:
543  case SVS_RAIL_CITY:
544  case SVS_RAIL_SLOW:
545  case SVS_RAIL_FAST:
546  case SVS_RAIL_CARGO:
547  glScaled(1. / (length), 1, 1.);
548  glTranslated(0, 0, .04);
549  glBegin(GL_TRIANGLE_FAN);
550  glVertex2d(length/ 2., 0);
551  glVertex2d(0, 0);
552  glVertex2d(0, -.45);
553  glVertex2d(.05, -.5);
554  glVertex2d(length - .05, -.5);
555  glVertex2d(length, -.45);
556  glVertex2d(length, .45);
557  glVertex2d(length - .05, .5);
558  glVertex2d(.05, .5);
559  glVertex2d(0, .45);
560  glVertex2d(0, 0);
561  glEnd();
562  glTranslated(0, 0, -.04);
563  break;
564  case SVS_E_VEHICLE:
565  drawPoly(vehiclePoly_EVehicleBody, 4);
566  glColor3d(0, 0, 0);
567  drawPoly(vehiclePoly_EVehicleFrontGlass, 4.5);
568  glTranslated(0, 0, .048);
569  GLHelper::setColor(current);
570  glBegin(GL_QUADS);
571  glVertex2d(.3, .5);
572  glVertex2d(.35, .5);
573  glVertex2d(.35, -.5);
574  glVertex2d(.3, -.5);
575 
576  glVertex2d(.3, -.05);
577  glVertex2d(.7, -.05);
578  glVertex2d(.7, .05);
579  glVertex2d(.3, .05);
580 
581  glVertex2d(.7, .5);
582  glVertex2d(.65, .5);
583  glVertex2d(.65, -.5);
584  glVertex2d(.7, -.5);
585  glEnd();
586  glTranslated(0, 0, -.048);
587  //drawPoly(vehiclePoly_EVehicleBackGlass, 4.5);
588  break;
589  case SVS_ANT:
590  glPushMatrix();
591  // ant is stretched via vehicle length
592  GLHelper::setColor(darker);
593  // draw left side
594  GLHelper::drawBoxLine(Position(-0.2, -.10), 350, 0.5, .02);
595  GLHelper::drawBoxLine(Position(-0.3, -.50), 240, 0.4, .03);
596  GLHelper::drawBoxLine(Position(0.3, -.10), 340, 0.8, .03);
597  GLHelper::drawBoxLine(Position(0.05, -.80), 290, 0.6, .04);
598  GLHelper::drawBoxLine(Position(0.4, -.10), 20, 0.8, .03);
599  GLHelper::drawBoxLine(Position(0.65, -.80), 75, 0.6, .04);
600  GLHelper::drawBoxLine(Position(0.5, -.10), 55, 0.8, .04);
601  GLHelper::drawBoxLine(Position(1.1, -.55), 90, 0.6, .04);
602  // draw right side
603  GLHelper::drawBoxLine(Position(-0.2, .10), 190, 0.5, .02);
604  GLHelper::drawBoxLine(Position(-0.3, .50), 300, 0.4, .03);
605  GLHelper::drawBoxLine(Position(0.3, .10), 200, 0.8, .03);
606  GLHelper::drawBoxLine(Position(0.05, .80), 250, 0.6, .04);
607  GLHelper::drawBoxLine(Position(0.4, .10), 160, 0.8, .03);
608  GLHelper::drawBoxLine(Position(0.65, .80), 105, 0.6, .04);
609  GLHelper::drawBoxLine(Position(0.5, .10), 125, 0.8, .04);
610  GLHelper::drawBoxLine(Position(1.1, .55), 90, 0.6, .04);
611  // draw body
612  GLHelper::setColor(current);
613  glTranslated(0, 0, 0.1);
615  glTranslated(.4, 0, 0);
617  glTranslated(.4, 0, 0);
619  glPopMatrix();
620  break;
621  default: // same as passenger
623  glColor3d(1, 1, 1);
624  drawPoly(vehiclePoly_PassengerCarBodyFront, 4.5);
625  glColor3d(0, 0, 0);
626  drawPoly(vehiclePoly_PassengerFrontGlass, 4.5);
627  break;
628  }
629 
630  // draw decorations
631  switch (shape) {
632  case SVS_PEDESTRIAN:
633  break;
634  case SVS_BICYCLE:
635  //glScaled(length, 1, 1.);
636  glBegin(GL_TRIANGLE_FAN);
637  glVertex2d(1 / 2., 0);
638  glVertex2d(0, 0);
639  glVertex2d(0, -.03);
640  glVertex2d(0 + .05, -.05);
641  glVertex2d(1 - .05, -.05);
642  glVertex2d(1, -.03);
643  glVertex2d(1, .03);
644  glVertex2d(1 - .05, .05);
645  glVertex2d(0 + .05, .05);
646  glVertex2d(0, .03);
647  glVertex2d(0, 0);
648  glEnd();
649  break;
650  case SVS_MOTORCYCLE:
651  //glScaled(length, 1, 1.);
652  glBegin(GL_TRIANGLE_FAN);
653  glVertex2d(1 / 2., 0);
654  glVertex2d(0, 0);
655  glVertex2d(0, -.03);
656  glVertex2d(0 + .05, -.2);
657  glVertex2d(1 - .05, -.2);
658  glVertex2d(1, -.03);
659  glVertex2d(1, .03);
660  glVertex2d(1 - .05, .2);
661  glVertex2d(0 + .05, .2);
662  glVertex2d(0, .03);
663  glVertex2d(0, 0);
664  glEnd();
665  break;
666  case SVS_PASSENGER:
667  case SVS_PASSENGER_SEDAN:
668  drawPoly(vehiclePoly_PassengerSedanRightGlass, 4.5);
669  drawPoly(vehiclePoly_PassengerSedanLeftGlass, 4.5);
670  drawPoly(vehiclePoly_PassengerSedanBackGlass, 4.5);
671  break;
673  drawPoly(vehiclePoly_PassengerHatchbackRightGlass, 4.5);
674  drawPoly(vehiclePoly_PassengerHatchbackLeftGlass, 4.5);
675  drawPoly(vehiclePoly_PassengerHatchbackBackGlass, 4.5);
676  break;
677  case SVS_PASSENGER_WAGON:
678  drawPoly(vehiclePoly_PassengerWagonRightGlass, 4.5);
679  drawPoly(vehiclePoly_PassengerWagonLeftGlass, 4.5);
680  drawPoly(vehiclePoly_PassengerWagonBackGlass, 4.5);
681  break;
682  case SVS_PASSENGER_VAN:
683  case SVS_DELIVERY:
684  break;
685  case SVS_TRANSPORT:
686  GLHelper::setColor(current);
687  GLHelper::drawBoxLine(Position(2.3, 0), 90., length - 2.3, .5);
688  break;
690  GLHelper::setColor(current);
691  GLHelper::drawBoxLine(Position(2.8, 0), 90., length - 2.8, .5);
692  break;
693  case SVS_TRANSPORT_1TRAILER: {
694  GLHelper::setColor(current);
695  SUMOReal l = length - 2.3;
696  l = l / 2.;
697  GLHelper::drawBoxLine(Position(2.3, 0), 90., l, .5);
698  GLHelper::drawBoxLine(Position(2.3 + l + .5, 0), 90., l - .5, .5);
699  break;
700  }
701  case SVS_BUS_TROLLEY:
702  glPushMatrix();
703  glTranslated(0, 0, .1);
704  GLHelper::setColor(darker);
705  GLHelper::drawBoxLine(Position(3.8, 0), 90., 1, .3);
706  glTranslated(0, 0, .1);
707  glColor3d(0, 0, 0);
708  GLHelper::drawBoxLine(Position(4.3, .2), 90., 1, .06);
709  GLHelper::drawBoxLine(Position(4.3, -.2), 90., 1, .06);
710  GLHelper::drawBoxLine(Position(5.3, .2), 90., 3, .03);
711  GLHelper::drawBoxLine(Position(5.3, -.2), 90., 3, .03);
712  glPopMatrix();
713  break;
714  case SVS_BUS:
715  case SVS_BUS_CITY:
717  case SVS_BUS_OVERLAND:
718  case SVS_RAIL:
719  case SVS_RAIL_LIGHT:
720  case SVS_RAIL_CITY:
721  case SVS_RAIL_SLOW:
722  case SVS_RAIL_FAST:
723  case SVS_RAIL_CARGO:
724  case SVS_E_VEHICLE:
725  case SVS_ANT:
726  break;
727  default: // same as passenger/sedan
728  drawPoly(vehiclePoly_PassengerSedanRightGlass, 4.5);
729  drawPoly(vehiclePoly_PassengerSedanLeftGlass, 4.5);
730  drawPoly(vehiclePoly_PassengerSedanBackGlass, 4.5);
731  break;
732  }
733  /*
734  glBegin(GL_TRIANGLE_FAN);
735  glVertex2d(.5,.5); // center - strip begin
736  glVertex2d(0, .5); // center, front
737  glVertex2d(0, .8); // ... clockwise ... (vehicle right side)
738  glVertex2d(0.08, .94);
739  glVertex2d(0.25, 1.);
740  glVertex2d(0.95, 1.);
741  glVertex2d(1., .9);
742  glVertex2d(1., .1); // (vehicle left side)
743  glVertex2d(0.95, 0.);
744  glVertex2d(0.25, 0.);
745  glVertex2d(0.08, .06);
746  glVertex2d(0, .2); //
747  glVertex2d(0, .5); // center, front (close)
748  glEnd();
749 
750  glPolygonOffset(0, -4.5);
751  glColor3d(1, 1, 1); // front
752  glBegin(GL_TRIANGLE_FAN);
753  glVertex2d(0.1,0.5);
754  glVertex2d(0.025,0.5);
755  glVertex2d(0.025,0.75);
756  glVertex2d(0.27,0.9);
757  glVertex2d(0.27,0.1);
758  glVertex2d(0.025,0.25);
759  glVertex2d(0.025,0.5);
760  glEnd();
761 
762  glColor3d(0, 0, 0); // front glass
763  glBegin(GL_TRIANGLE_FAN);
764  glVertex2d(0.35,0.5);
765  glVertex2d(0.3,0.5);
766  glVertex2d(0.3,0.9);
767  glVertex2d(0.43,0.8);
768  glVertex2d(0.43,0.2);
769  glVertex2d(0.3,0.1);
770  glVertex2d(0.3,0.5);
771  glEnd();
772 
773  glBegin(GL_TRIANGLE_FAN); // back glass
774  glVertex2d(0.92,0.5);
775  glVertex2d(0.90,0.5);
776  glVertex2d(0.90,0.8);
777  glVertex2d(0.95,0.9);
778  glVertex2d(0.95,0.1);
779  glVertex2d(0.90,0.2);
780  glVertex2d(0.90,0.5);
781  glEnd();
782 
783  glBegin(GL_TRIANGLE_FAN); // right glass
784  glVertex2d(0.36,0.07);
785  glVertex2d(0.34,0.03);
786  glVertex2d(0.94,0.03);
787  glVertex2d(0.87,0.13);
788  glVertex2d(0.45,0.13);
789  glVertex2d(0.34,0.03);
790  glEnd();
791 
792  glBegin(GL_TRIANGLE_FAN); // left glass
793  glVertex2d(0.36,1.-0.07);
794  glVertex2d(0.34,1.-0.03);
795  glVertex2d(0.94,1.-0.03);
796  glVertex2d(0.87,1.-0.13);
797  glVertex2d(0.45,1.-0.13);
798  glVertex2d(0.34,1.-0.03);
799  glEnd();
800  */
801 
802  glPopMatrix();
803 }
804 
805 
806 #define BLINKER_POS_FRONT .5
807 #define BLINKER_POS_BACK .5
808 
809 inline void
810 drawAction_drawBlinker(const GUIVehicle& veh, double dir) {
811  glColor3d(1.f, .8f, 0);
812  glPushMatrix();
813  glTranslated(dir, BLINKER_POS_FRONT, -0.1);
815  glPopMatrix();
816  glPushMatrix();
817  glTranslated(dir, veh.getVehicleType().getLength() - BLINKER_POS_BACK, -0.1);
819  glPopMatrix();
820 }
821 
822 
823 inline void
826  return;
827  }
828  const double offset = MAX2(.5 * veh.getVehicleType().getWidth(), .4);
830  drawAction_drawBlinker(veh, -offset);
831  }
833  drawAction_drawBlinker(veh, offset);;
834  }
836  drawAction_drawBlinker(veh, -offset);
837  drawAction_drawBlinker(veh, offset);
838  }
839 }
840 
841 
842 inline void
845  return;
846  }
847  glColor3f(1.f, .2f, 0);
848  glPushMatrix();
849  glTranslated(-veh.getVehicleType().getWidth() * 0.5, veh.getVehicleType().getLength(), -0.1);
851  glPopMatrix();
852  glPushMatrix();
853  glTranslated(veh.getVehicleType().getWidth() * 0.5, veh.getVehicleType().getLength(), -0.1);
855  glPopMatrix();
856 }
857 
858 
859 void
861  glPushName(getGlID());
862  glPushMatrix();
864  glTranslated(p1.x(), p1.y(), getType());
865  glRotated(getAngle(), 0, 0, 1);
866  // set lane color
867  setColor(s);
868  // scale
869  SUMOReal upscale = s.vehicleExaggeration;
870  glScaled(upscale, upscale, 1);
871  /*
872  MSLCM_DK2004 &m2 = static_cast<MSLCM_DK2004&>(veh->getLaneChangeModel());
873  if((m2.getState()&LCA_URGENT)!=0) {
874  glColor3d(1, .4, .4);
875  } else if((m2.getState()&LCA_SPEEDGAIN)!=0) {
876  glColor3d(.4, .4, 1);
877  } else {
878  glColor3d(.4, 1, .4);
879  }
880  */
881  // draw the vehicle
882  switch (s.vehicleQuality) {
883  case 0:
885  break;
886  case 1:
888  break;
889  case 2:
890  default:
892  break;
893  }
894  if (s.drawMinGap) {
895  SUMOReal minGap = -getVehicleType().getMinGap();
896  glColor3d(0., 1., 0.);
897  glBegin(GL_LINES);
898  glVertex2d(0., 0);
899  glVertex2d(0., minGap);
900  glVertex2d(-.5, minGap);
901  glVertex2d(.5, minGap);
902  glEnd();
903  }
904  // draw the blinker and brakelights if wished
905  if (s.showBlinker) {
906  glTranslated(0, 0, .1);
907  switch (getVehicleType().getGuiShape()) {
908  case SVS_PEDESTRIAN:
909  case SVS_BICYCLE:
910  case SVS_ANT:
911  case SVS_RAIL:
912  case SVS_RAIL_LIGHT:
913  case SVS_RAIL_SLOW:
914  case SVS_RAIL_FAST:
915  case SVS_RAIL_CARGO:
916  // only SVS_RAIL_CITY has blinkers and brake lights
917  break;
918  default:
921  break;
922  }
923  }
924  // draw the wish to change the lane
925  if (s.drawLaneChangePreference) {
926  /*
927  if(gSelected.isSelected(GLO_VEHICLE, veh->getGlID())) {
928  MSLCM_DK2004 &m = static_cast<MSLCM_DK2004&>(veh->getLaneChangeModel());
929  glColor3d(.5, .5, 1);
930  glBegin(GL_LINES);
931  glVertex2f(0, 0);
932  glVertex2f(m.getChangeProbability(), .5);
933  glEnd();
934 
935  glColor3d(1, 0, 0);
936  glBegin(GL_LINES);
937  glVertex2f(0.1, 0);
938  glVertex2f(0.1, m.myMaxJam1);
939  glEnd();
940 
941  glColor3d(0, 1, 0);
942  glBegin(GL_LINES);
943  glVertex2f(-0.1, 0);
944  glVertex2f(-0.1, m.myTDist);
945  glEnd();
946  }
947  */
948  }
949  // draw best lanes
950  if (true) {
951  /*
952  const MSLane &l = veh->getLane();
953  SUMOReal r1 = veh->allowedContinuationsLength(&l, 0);
954  SUMOReal r2 = l.getLeftLane()!=0 ? veh->allowedContinuationsLength(l.getLeftLane(), 0) : 0;
955  SUMOReal r3 = l.getRightLane()!=0 ? veh->allowedContinuationsLength(l.getRightLane(), 0) : 0;
956  SUMOReal mmax = MAX3(r1, r2, r3);
957  glBegin(GL_LINES);
958  glVertex2f(0, 0);
959  glVertex2f(0, r1/mmax/2.);
960  glEnd();
961  glBegin(GL_LINES);
962  glVertex2f(.4, 0);
963  glVertex2f(.4, r2/mmax/2.);
964  glEnd();
965  glBegin(GL_LINES);
966  glVertex2f(-.4, 0);
967  glVertex2f(-.4, r3/mmax/2.);
968  glEnd();
969  */
970  }
971  glPopMatrix();
973  s.scale, s.vehicleName);
974  glPopName();
975 }
976 
977 
978 void
980  glPushName(getGlID());
981  glPushMatrix();
982  glTranslated(0, 0, getType() - .1); // don't draw on top of other cars
984  drawBestLanes();
985  }
987  drawRoute(s, 0, 0.25);
988  }
990  if (getNumberReroutes() > 0) {
991  const int noReroutePlus1 = getNumberReroutes() + 1;
992  for (int i = noReroutePlus1 - 1; i >= 0; i--) {
993  SUMOReal darken = SUMOReal(0.4) / SUMOReal(noReroutePlus1) * SUMOReal(i);
994  drawRoute(s, i, darken);
995  }
996  } else {
997  drawRoute(s, 0, 0.25);
998  }
999  }
1001  for (DriveItemVector::const_iterator i = myLFLinkLanes.begin(); i != myLFLinkLanes.end(); ++i) {
1002  if((*i).myLink==0) {
1003  continue;
1004  }
1005  MSLink* link = (*i).myLink;
1006 #ifdef HAVE_INTERNAL_LANES
1007  MSLane *via = link->getViaLane();
1008  if (via == 0) {
1009  via = link->getLane();
1010  }
1011 #else
1012  MSLane *via = link->getLane();
1013 #endif
1014  if (via != 0) {
1015  Position p = via->getShape()[0];
1016  if((*i).mySetRequest) {
1017  glColor3f(0, 1, 0);
1018  } else {
1019  glColor3f(1, 0, 0);
1020  }
1021  glTranslated(p.x(), p.y(), -.1);
1023  glTranslated(-p.x(), -p.y(), .1);
1024  }
1025  }
1026  }
1027  glPopMatrix();
1028  glPopName();
1029 }
1030 
1031 
1032 const std::vector<MSVehicle::LaneQ> &
1034  myLock.lock();
1035  const std::vector<MSVehicle::LaneQ> &ret = MSVehicle::getBestLanes();
1036  myLock.unlock();
1037  return ret;
1038 }
1039 
1040 
1041 void
1043  const GUIColorer& c = s.vehicleColorer;
1044  if (!setFunctionalColor(c.getActive())) {
1046  }
1047 }
1048 
1049 
1050 bool
1051 GUIVehicle::setFunctionalColor(size_t activeScheme) const {
1052  switch (activeScheme) {
1053  case 1: {
1055  return true;
1056  }
1057  case 2: {
1058  GLHelper::setColor(getVehicleType().getColor());
1059  return true;
1060  }
1061  case 3: {
1062  GLHelper::setColor(getRoute().getColor());
1063  return true;
1064  }
1065  case 4: {
1066  Position p = getRoute().getEdges()[0]->getLanes()[0]->getShape()[0];
1067  const Boundary& b = ((GUINet*) MSNet::getInstance())->getBoundary();
1068  Position center = b.getCenter();
1069  SUMOReal hue = 180. + atan2(center.x() - p.x(), center.y() - p.y()) * 180. / PI;
1070  SUMOReal sat = p.distanceTo(center) / center.distanceTo(Position(b.xmin(), b.ymin()));
1071  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1072  return true;
1073  }
1074  case 5: {
1075  Position p = getRoute().getEdges().back()->getLanes()[0]->getShape()[-1];
1076  const Boundary& b = ((GUINet*) MSNet::getInstance())->getBoundary();
1077  Position center = b.getCenter();
1078  SUMOReal hue = 180. + atan2(center.x() - p.x(), center.y() - p.y()) * 180. / PI;
1079  SUMOReal sat = p.distanceTo(center) / center.distanceTo(Position(b.xmin(), b.ymin()));
1080  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1081  return true;
1082  }
1083  case 6: {
1084  Position pb = getRoute().getEdges()[0]->getLanes()[0]->getShape()[0];
1085  Position pe = getRoute().getEdges().back()->getLanes()[0]->getShape()[-1];
1086  const Boundary& b = ((GUINet*) MSNet::getInstance())->getBoundary();
1087  SUMOReal hue = 180. + atan2(pb.x() - pe.x(), pb.y() - pe.y()) * 180. / PI;
1088  Position minp(b.xmin(), b.ymin());
1089  Position maxp(b.xmax(), b.ymax());
1090  SUMOReal sat = pb.distanceTo(pe) / minp.distanceTo(maxp);
1091  GLHelper::setColor(RGBColor::fromHSV(hue, sat, 1.));
1092  return true;
1093  }
1094  }
1095  return false;
1096 }
1097 
1098 
1099 SUMOReal
1100 GUIVehicle::getColorValue(size_t activeScheme) const {
1101  switch (activeScheme) {
1102  case 7:
1103  return getSpeed();
1104  case 8:
1105  return getWaitingSeconds();
1106  case 9:
1107  return getLastLaneChangeOffset();
1108  case 10:
1109  return getMaxSpeed();
1110  case 11:
1111  return getHBEFA_CO2Emissions();
1112  case 12:
1113  return getHBEFA_COEmissions();
1114  case 13:
1115  return getHBEFA_PMxEmissions();
1116  case 14:
1117  return getHBEFA_NOxEmissions();
1118  case 15:
1119  return getHBEFA_HCEmissions();
1120  case 16:
1121  return getHBEFA_FuelConsumption();
1122  case 17:
1124  case 18:
1125  if (getNumberReroutes() == 0) {
1126  return -1;
1127  }
1128  return getNumberReroutes();
1129  }
1130  return 0;
1131 }
1132 
1133 
1134 // ------------ Additional visualisations
1135 bool
1137  return myAdditionalVisualizations.find(parent) != myAdditionalVisualizations.end() && (myAdditionalVisualizations.find(parent)->second & which) != 0;
1138 }
1139 
1140 
1141 bool
1143  if (myAdditionalVisualizations.find(parent) == myAdditionalVisualizations.end()) {
1144  myAdditionalVisualizations[parent] = 0;
1145  }
1146  myAdditionalVisualizations[parent] |= which;
1147  return parent->addAdditionalGLVisualisation(this);
1148 }
1149 
1150 
1151 bool
1153  myAdditionalVisualizations[parent] &= ~which;
1154  return parent->removeAdditionalGLVisualisation(this);
1155 }
1156 
1157 
1158 void
1159 GUIVehicle::drawRoute(const GUIVisualizationSettings& s, int routeNo, SUMOReal darken) const {
1160  setColor(s);
1161  GLdouble colors[4];
1162  glGetDoublev(GL_CURRENT_COLOR, colors);
1163  colors[0] -= darken;
1164  if (colors[0] < 0) {
1165  colors[0] = 0;
1166  }
1167  colors[1] -= darken;
1168  if (colors[1] < 0) {
1169  colors[1] = 0;
1170  }
1171  colors[2] -= darken;
1172  if (colors[2] < 0) {
1173  colors[2] = 0;
1174  }
1175  colors[3] -= darken;
1176  if (colors[3] < 0) {
1177  colors[3] = 0;
1178  }
1179  glColor3dv(colors);
1180  if (routeNo == 0) {
1181  draw(*myRoute);
1182  return;
1183  }
1184  --routeNo; // only prior routes are stored
1185  draw(*myRoutes->getRoute(routeNo));
1186 }
1187 
1188 
1189 void
1191  myLock.lock();
1192  std::vector<std::vector<MSVehicle::LaneQ> > bestLanes = myBestLanes;
1193  myLock.unlock();
1194  SUMOReal width = 0.5;
1195  for (std::vector<std::vector<MSVehicle::LaneQ> >::iterator j = bestLanes.begin(); j != bestLanes.end(); ++j) {
1196  std::vector<MSVehicle::LaneQ> &lanes = *j;
1197  SUMOReal gmax = -1;
1198  SUMOReal rmax = -1;
1199  for (std::vector<MSVehicle::LaneQ>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
1200  gmax = MAX2((*i).length, gmax);
1201  rmax = MAX2((*i).occupation, rmax);
1202  }
1203  for (std::vector<MSVehicle::LaneQ>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
1204  const PositionVector& shape = (*i).lane->getShape();
1205  SUMOReal g = (*i).length / gmax;
1206  SUMOReal r = (*i).occupation / rmax;
1207  glColor3d(r, g, 0);
1208  GLHelper::drawBoxLines(shape, width);
1209 
1210  PositionVector s1 = shape;
1211  s1.move2side((SUMOReal) .1);
1212  glColor3d(r, 0, 0);
1213  GLHelper::drawLine(s1);
1214  s1.move2side((SUMOReal) - .2);
1215  glColor3d(0, g, 0);
1216  GLHelper::drawLine(s1);
1217 
1218  glColor3d(r, g, 0);
1219  Position lastPos = shape[-1];
1220  }
1221  width = .2;
1222  }
1223 }
1224 
1225 
1226 void
1227 GUIVehicle::draw(const MSRoute& r) const {
1228  MSRouteIterator i = r.begin();
1229  for (; i != r.end(); ++i) {
1230  const MSEdge* e = *i;
1231  const GUIEdge* ge = static_cast<const GUIEdge*>(e);
1232  const GUILaneWrapper& lane = ge->getLaneGeometry((size_t) 0);
1234  }
1235 }
1236 
1237 
1238 /****************************************************************************/
1239