Tulip 5.7.1
Large graphs analysis and drawing
Loading...
Searching...
No Matches
GlScene.h
1/*
2 *
3 * This file is part of Tulip (https://tulip.labri.fr)
4 *
5 * Authors: David Auber and the Tulip development Team
6 * from LaBRI, University of Bordeaux
7 *
8 * Tulip is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation, either version 3
11 * of the License, or (at your option) any later version.
12 *
13 * Tulip is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 * See the GNU General Public License for more details.
17 *
18 */
19
20#ifndef Tulip_GLSCENE_H
21#define Tulip_GLSCENE_H
22
23#include <climits>
24
25#include <tulip/tulipconf.h>
26#include <tulip/BoundingBox.h>
27#include <tulip/GlLODCalculator.h>
28#include <tulip/GlLayer.h>
29#include <tulip/Color.h>
30#include <tulip/Observable.h>
31
32namespace tlp {
33
34class GlSimpleEntity;
35class Graph;
36class GlGraphComposite;
37
38/**
39 * @ingroup OpenGL
40 * @brief Structure to store selected entities
41 *
42 * After a selection, objects of SelectedEntity is returned
43 * To use this object the first thing to do is to call getEntity type to know the type of Entity
44 * After that you can :
45 * - Get the GlSimpleEntity pointer (getSimpleEntity())
46 * - Get the id of node/edge and the graph associated (getComplexEntityId() and
47 * getComplexEntityGraph())
48 *
49 */
51
52 enum SelectedEntityType {
53 UNKNOW_SELECTED = 0,
54 NODE_SELECTED = 1,
55 EDGE_SELECTED = 2,
56 SIMPLE_ENTITY_SELECTED = 3
57 };
58
60 : simpleEntity(nullptr), complexEntityId(UINT_MAX), entityType(UNKNOW_SELECTED) {}
62 : simpleEntity(entity), complexEntityId(UINT_MAX), entityType(SIMPLE_ENTITY_SELECTED) {}
63 SelectedEntity(Graph *graph, unsigned int id, SelectedEntityType type)
64 : complexEntityGraph(graph), complexEntityId(id), entityType(type) {
65 assert((type == NODE_SELECTED) || (type == EDGE_SELECTED));
66 }
67
68 GlSimpleEntity *getSimpleEntity() const {
69 assert((entityType == SIMPLE_ENTITY_SELECTED) && (simpleEntity != nullptr));
70 return simpleEntity;
71 }
72
73 unsigned int getComplexEntityId() const {
74 assert((entityType != SIMPLE_ENTITY_SELECTED) && (complexEntityId != UINT_MAX));
75 return complexEntityId;
76 }
77
78 Graph *getComplexEntityGraph() const {
79 assert((entityType != SIMPLE_ENTITY_SELECTED) && (complexEntityGraph != nullptr));
80 return complexEntityGraph;
81 }
82
83 SelectedEntityType getEntityType() const {
84 return entityType;
85 }
86 /**
87 * @return the selected node if the entity type is correct or an invalid node else.
88 */
89 node getNode() const {
90 assert((entityType == NODE_SELECTED) || (complexEntityId == UINT_MAX));
91 return node(complexEntityId);
92 }
93
94 /**
95 * @return the selected edge if the entity type is correct or an invalid edge else.
96 */
97 edge getEdge() const {
98 assert((entityType == EDGE_SELECTED) || (complexEntityId == UINT_MAX));
99 return edge(complexEntityId);
100 }
101
102protected:
103 union {
104 GlSimpleEntity *simpleEntity;
105 Graph *complexEntityGraph;
106 };
107 unsigned int complexEntityId;
108 SelectedEntityType entityType;
109};
110
111/**
112 * @ingroup OpenGL
113 * @brief Tulip scene class
114 *
115 * The GlScene class is the core of the tulip rendering system
116 * This class is used to render entities and graph in OpenGL
117 *
118 * If you want to render entities and graph, you have to use GlLayer system. You just have to create
119 * GlLayer and add GlEntity in.
120 * If you create more than one GlLayer, layers are rendered one after one, so the first GlLayer
121 * added is rendered in first.
122 * @see GlLayer
123 * @see GlSimpleEntity
124 *
125 *
126 * After adding layers you can do a centerScene() and a draw()
127 *
128 * \code
129 * GlLayer *mainLayer=new GlLayer("Main");
130 * GlGraphComposite *graphComposite=new GlGraphComposite(graph);
131 * mainLayer->addGlEntity(graphComposite,"graph");
132 * GlLayer *otherLayer=new GlLayer("Other");
133 * GlCircle *circle=new GlCircle();
134 * otherLayer->addGlEntity(circle,"circle");
135 * glScene.addLayer(mainLayer);
136 * glScene.addLayer(otherLayer);
137 * glScene.centerScene();
138 * glScene.draw();
139 * \endcode
140 *
141 * If you want to create a widget with a visualisation is better to use GlMainWidget class (this
142 * class use a GlScene inside)
143 */
144class TLP_GL_SCOPE GlScene : public Observable {
145
146public:
147 /** \brief Constructor
148 * Default scene is empty
149 * @param calculator By default GlScene use a GlCPULODCalculator to compute LOD but you can change
150 * this default lod calculator, to do that : put your calculator in constructor parameters
151 * Available calculators are : GlCPULODCalculator and GlQuadTreeLODCalculator
152 */
153 GlScene(GlLODCalculator *calculator = nullptr);
154
155 ~GlScene() override;
156
157 /**
158 * @brief Init scene's OpenGL parameters.
159 * You don't have to call this function, it is call when you do a draw
160 */
162
163 /**
164 * @brief Draw the scene
165 * This function is the most important function of GlScene. If you want to render a scene into an
166 * OpenGL widget : call this function
167 */
168 void draw();
169
170 /**
171 * Center scene
172 * After this function all entities are visible on the screen
173 */
175
176 /**
177 * Compute information for adjustSceneToSize
178 * @param width request width
179 * @param height request height
180 * @param center the result center will be stored in (if center != nullptr)
181 * @param eye the result eye will be stored in (if eye != nullptr)
182 * @param sceneRadius the result sceneRadius will be stored in (if sceneRadius != nullptr)
183 * @param xWhiteFactor the white part on x borders (left and right), the computed empty space size
184 * will be stored in (if xWhiteFactor != nullptr)
185 * @param yWhiteFactor the white part on y borders (top and bottom), the computed empty space size
186 * will be stored in (if yWhiteFactor != nullptr)
187 * @param sceneBoundingBox the computed sceneBoundingBox will be stored in (if sceneBoundingBox !=
188 * nullptr)
189 * @param zoomFactor the computed zoomFactor will be stored in (if zoomFactor != nullptr)
190 */
191 void computeAdjustSceneToSize(int width, int height, Coord *center, Coord *eye,
192 float *sceneRadius, float *xWhiteFactor, float *yWhiteFactor,
193 BoundingBox *sceneBoundingBox = nullptr,
194 float *zoomFactor = nullptr);
195
196 // use computeAdjustSceneToSize instead
197 _DEPRECATED void computeAjustSceneToSize(int width, int height, Coord *center, Coord *eye,
198 float *sceneRadius, float *xWhiteFactor,
199 float *yWhiteFactor,
200 BoundingBox *sceneBoundingBox = nullptr,
201 float *zoomFactor = nullptr) {
202 computeAdjustSceneToSize(width, height, center, eye, sceneRadius, xWhiteFactor, yWhiteFactor,
203 sceneBoundingBox, zoomFactor);
204 }
205
206 /**
207 * Adjust camera to have entities near borders
208 * @param width requested width
209 * @param height requested height
210 */
211 void adjustSceneToSize(int width, int height);
212
213 _DEPRECATED inline void ajustSceneToSize(int width, int height) {
214 adjustSceneToSize(width, height);
215 }
216
217 /**
218 * @brief Zoom by step to given x,y screen coordinates
219 * @param step of zoom
220 */
221 void zoomXY(int step, const int x, const int y);
222
223 /**
224 * @brief Zoom by factor
225 * @param factor of zoom
226 */
227 void zoomFactor(float factor);
228
229 /**
230 * @brief Zoom to given world coordinate
231 * \warning factor parameter isn't be used
232 */
233 void zoom(float factor, const Coord &dest);
234
235 /**
236 * @brief Zoom by step
237 * @param step of zoom
238 */
239 void zoom(int step) {
240 zoomFactor(powf(1.1f, step));
241 }
242
243 /**
244 * @brief Translate camera by (x,y,z)
245 */
246 void translateCamera(const int x, const int y, const int z);
247
248 /**
249 * @brief Rotate camera by (x,y,z)
250 * @param x rotation over X axis in degree
251 * @param y rotation over Y axis in degree
252 * @param z rotation over Z axis in degree
253 */
254 void rotateCamera(const int x, const int y, const int z);
255
256 // use rotateCamera instead
257 _DEPRECATED inline void rotateScene(const int x, const int y, const int z) {
258 rotateCamera(x, y, z);
259 }
260
261 /**
262 * @brief Select entities in scene
263 * @param type Entities type to select (SelectSimpleEntities,SelectNodes,SelectEdges)
264 * @param x screen coordinates
265 * @param y screen coordinates
266 * @param h height in screen coordinates
267 * @param w width in screen coordinates
268 * @param layer where the selection will be performed
269 * @param selectedEntities the result of the selection is stored on it
270 */
271 bool selectEntities(RenderingEntitiesFlag type, int x, int y, int h, int w, GlLayer *layer,
272 std::vector<SelectedEntity> &selectedEntities);
273
274 /**
275 * @brief Return the RGB image of GlScene
276 */
277 unsigned char *getImage();
278
279 /**
280 * @brief Set the viewport of the scene with a vector
281 * The viewport must be in many case the size of the widget containing the scene
282 */
283 void setViewport(Vector<int, 4> &newViewport) {
284 viewport = newViewport;
285 }
286
287 /**
288 * @brief Set the viewport of the scene with 4 int
289 * The viewport must be in many case the size of the widget containing the scene
290 */
291 void setViewport(int x, int y, int width, int height) {
292 viewport[0] = x;
293 viewport[1] = y;
294 viewport[2] = width;
295 viewport[3] = height;
296 }
297
298 /**
299 * @brief Get the viewport of the scene
300 * The viewport will be in many case the size of the widget containing the scene
301 */
302 const Vector<int, 4> &getViewport() const {
303 return viewport;
304 }
305
306 /**
307 * @brief Set the background color of the scene
308 */
309 void setBackgroundColor(const Color &color) {
310 backgroundColor = color;
311 }
312
313 /**
314 * @brief Get the background color of the scene
315 */
316 Color getBackgroundColor() const {
317 return backgroundColor;
318 }
319
320 /**
321 * @brief Set if scene is render in orthogonal mode
322 */
323 void setViewOrtho(bool viewOrtho) {
324 this->viewOrtho = viewOrtho;
325 }
326
327 /**
328 * @brief Scene is render in orthogonal mode ?
329 */
330 bool isViewOrtho() {
331 return viewOrtho;
332 }
333
334 /**
335 * @brief Create a layer with the given name in the scene
336 * This layer is added to the layers list
337 * Now the scene have the ownership of this GlLayer
338 * so you don't have to delete this GlLayer
339 */
340 GlLayer *createLayer(const std::string &name);
341
342 /**
343 * @brief Create a layer with the given name in the scene just before layer with given name
344 * This layer is added to the layers list
345 * Return nullptr if the layer with beforeLayerWithName is not find
346 * Now the scene have the ownership of this GlLayer
347 * so you don't have to delete this GlLayer
348 */
349 GlLayer *createLayerBefore(const std::string &layerName, const std::string &beforeLayerWithName);
350
351 /**
352 * @brief Create a layer with the given name in the scene just after layer with given name
353 * This layer is added to the layers list
354 * Return nullptr if the layer with beforeLayerWithName is not find
355 * Now the scene have the ownership of this GlLayer
356 * so you don't have to delete this GlLayer
357 */
358 GlLayer *createLayerAfter(const std::string &layerName, const std::string &afterLayerWithName);
359
360 /**
361 * @brief Add an existing layer in the scene
362 * Now the scene have the ownership of this GlLayer
363 * so you don't have to delete this GlLayer
364 */
366
367 /**
368 * @brief Add an existing layer in the scene just before layer with given name
369 * Return false if the layer with beforeLayerWithName is not find
370 * Now the scene have the ownership of this GlLayer
371 * so you don't have to delete this GlLayer
372 */
373 bool addExistingLayerBefore(GlLayer *layer, const std::string &beforeLayerWithName);
374
375 /**
376 * @brief Add an existing layer in the scene just after layer with given name
377 * Return false if the layer with beforeLayerWithName is not find
378 * Now the scene have the ownership of this GlLayer
379 * so you don't have to delete this GlLayer
380 */
381 bool addExistingLayerAfter(GlLayer *layer, const std::string &afterLayerWithName);
382
383 /**
384 * @brief Return the layer with name : name
385 * Return nullptr if the layer doesn't exist in the scene
386 */
387 GlLayer *getLayer(const std::string &name);
388
389 /**
390 * @brief Remove the layer with name
391 * This GlLayer is automatically deleted
392 * If you want to keep this GlLayer you can put false to deleteLayer parameters
393 * but after that you have the ownership of the GlLayer
394 */
395 void removeLayer(const std::string &name, bool deleteLayer = true);
396
397 /**
398 * @brief Remove the layer with name
399 * This GlLayer is automatically deleted
400 * If you want to keep this GlLayer you can put false to deleteLayer parameters
401 * but after that you have the ownership of the GlLayer
402 */
403 void removeLayer(GlLayer *layer, bool deleteLayer = true);
404
405 /**
406 * @brief Return the layer list
407 */
408 const std::vector<std::pair<std::string, GlLayer *>> &getLayersList() {
409 return layersList;
410 }
411
412 /**
413 * @brief Clear layers list
414 * Layers will not be deleted in this function
415 */
417 for (auto &it : layersList)
418 delete it.second;
419
420 layersList.clear();
421 }
422
423 /**
424 * @brief Get XML description of the scene and children and store it in out string
425 */
426 void getXML(std::string &out);
427
428 /**
429 * @brief Get XML description of cameras of the scene and store it in out string
430 */
431 void getXMLOnlyForCameras(std::string &out);
432
433 /**
434 * @brief Set scene's data and children with a XML
435 */
436 void setWithXML(std::string &in, Graph *graph);
437
438 /**
439 * @brief Return lod calculator used to render this scene
440 */
441 GlLODCalculator *getCalculator() {
442 return lodCalculator;
443 }
444
445 /**
446 * @brief Set a new lod calculator used to render this scene
447 */
448 void setCalculator(GlLODCalculator *calculator) {
449 lodCalculator = calculator;
450 calculator->setScene(*this);
451 }
452
453 /**
454 * @brief Return the bounding box of the scene (in 3D coordinates)
455 * \warning This bounding box is computed in rendering, so if you add an entity in a layer the
456 * bounding box includes this entity if a draw is called
457 */
459
460 /**
461 * @brief Return the current GlGraphComposite used by the scene
462 */
464 return glGraphComposite;
465 }
466
467 /**
468 * @brief Return the layer containing the current GlGraphComposite
469 */
471 return graphLayer;
472 }
473
474 /**
475 * @brief By default the most important layer is the layer where the graph is visualized
476 * This function return the camera of this layer
477 */
479 assert(graphLayer != nullptr);
480 return graphLayer->getCamera();
481 }
482
483 /**
484 * @brief By default the most important layer is the layer where the graph is visualized
485 * This function set the camera of this layer
486 */
487 void setGraphCamera(Camera *camera) {
488 assert(graphLayer != nullptr);
489 graphLayer->setCamera(camera);
490 }
491
492 /**
493 * @brief Set if OpenGL buffer will be cleared at draw
494 */
495 void setClearBufferAtDraw(bool clear) {
496 clearBufferAtDraw = clear;
497 }
498
499 /**
500 * @brief If false, color buffer will not be cleared before drawing the scene.
501 */
502 bool getClearBufferAtDraw() const {
503 return clearBufferAtDraw;
504 }
505
506 /**
507 * @brief Set if OpenGL depth buffer will be cleared at draw
508 */
509 void setClearDepthBufferAtDraw(bool clear) {
510 clearDepthBufferAtDraw = clear;
511 }
512
513 /**
514 * @brief If false, depth buffer will not be cleared before drawing the scene.
515 */
517 return clearDepthBufferAtDraw;
518 }
519
520 /**
521 * @brief Set if OpenGL stencil buffer will be cleared at draw
522 */
524 clearStencilBufferAtDraw = clear;
525 }
526
527 /**
528 * @brief If false, color buffer will not be cleared before drawing the scene.
529 */
531 return clearStencilBufferAtDraw;
532 }
533
534private:
535 std::vector<std::pair<std::string, GlLayer *>> layersList;
536 GlLODCalculator *lodCalculator;
537 Vector<int, 4> viewport;
538 Color backgroundColor;
539 bool viewOrtho;
540
541 GlGraphComposite *glGraphComposite;
542 GlLayer *graphLayer;
543
544 bool clearBufferAtDraw;
545
546 bool inDraw;
547
548 bool clearDepthBufferAtDraw;
549
550 bool clearStencilBufferAtDraw;
551
552public:
553 ///@cond DOXYGEN_HIDDEN
554
555 /**
556 * @brief You don't have to call this function
557 * This function is automatically called when a GlGraphComposite is added in a layer in the scene
558 * You don't have to call this function
559 */
560 void glGraphCompositeAdded(GlLayer *layer, GlGraphComposite *composite);
561
562 /**
563 * @brief You don't have to call this function
564 * This function is automatically called when a GlGraphComposite is added in a layer in the scene
565 * You don't have to call this function
566 */
567 void glGraphCompositeRemoved(GlLayer *layer, GlGraphComposite *composite);
568
569 /**
570 * @brief You don't have to call this function
571 * This function is called by GlLayer and GlComposite to send layer modification event
572 */
573 void notifyModifyLayer(const std::string &name, GlLayer *layer);
574
575 /**
576 * @brief You don't have to call these functions
577 * They are called by GlComposite to send entity modification event
578 */
579 void notifyModifyEntity(GlSimpleEntity *entity);
580 void notifyDeletedEntity(GlSimpleEntity *entity);
581
582 ///@endcond
583};
584} // namespace tlp
585
586#endif // Tulip_GLSCENE_H
Tulip OpenGL camera object.
Definition: Camera.h:47
Class use to visualize graph in OpenGL Tulip engine.
A GlLayer is like an 2D drawing software layer system.
Definition: GlLayer.h:54
Tulip scene class.
Definition: GlScene.h:144
void setViewport(Vector< int, 4 > &newViewport)
Set the viewport of the scene with a vector The viewport must be in many case the size of the widget ...
Definition: GlScene.h:283
Camera & getGraphCamera()
By default the most important layer is the layer where the graph is visualized This function return t...
Definition: GlScene.h:478
void zoomFactor(float factor)
Zoom by factor.
void addExistingLayer(GlLayer *layer)
Add an existing layer in the scene Now the scene have the ownership of this GlLayer so you don't have...
GlLayer * getGraphLayer()
Return the layer containing the current GlGraphComposite.
Definition: GlScene.h:470
GlLODCalculator * getCalculator()
Return lod calculator used to render this scene.
Definition: GlScene.h:441
void getXML(std::string &out)
Get XML description of the scene and children and store it in out string.
bool selectEntities(RenderingEntitiesFlag type, int x, int y, int h, int w, GlLayer *layer, std::vector< SelectedEntity > &selectedEntities)
Select entities in scene.
void getXMLOnlyForCameras(std::string &out)
Get XML description of cameras of the scene and store it in out string.
void setCalculator(GlLODCalculator *calculator)
Set a new lod calculator used to render this scene.
Definition: GlScene.h:448
bool getClearStencilBufferAtDraw() const
If false, color buffer will not be cleared before drawing the scene.
Definition: GlScene.h:530
unsigned char * getImage()
Return the RGB image of GlScene.
BoundingBox getBoundingBox()
Return the bounding box of the scene (in 3D coordinates)
GlScene(GlLODCalculator *calculator=nullptr)
Constructor Default scene is empty.
void setViewOrtho(bool viewOrtho)
Set if scene is render in orthogonal mode.
Definition: GlScene.h:323
void zoomXY(int step, const int x, const int y)
Zoom by step to given x,y screen coordinates.
void centerScene()
const Vector< int, 4 > & getViewport() const
Get the viewport of the scene The viewport will be in many case the size of the widget containing the...
Definition: GlScene.h:302
void setWithXML(std::string &in, Graph *graph)
Set scene's data and children with a XML.
void setViewport(int x, int y, int width, int height)
Set the viewport of the scene with 4 int The viewport must be in many case the size of the widget con...
Definition: GlScene.h:291
bool getClearDepthBufferAtDraw() const
If false, depth buffer will not be cleared before drawing the scene.
Definition: GlScene.h:516
bool addExistingLayerAfter(GlLayer *layer, const std::string &afterLayerWithName)
Add an existing layer in the scene just after layer with given name Return false if the layer with be...
bool addExistingLayerBefore(GlLayer *layer, const std::string &beforeLayerWithName)
Add an existing layer in the scene just before layer with given name Return false if the layer with b...
void setBackgroundColor(const Color &color)
Set the background color of the scene.
Definition: GlScene.h:309
void rotateCamera(const int x, const int y, const int z)
Rotate camera by (x,y,z)
void initGlParameters()
Init scene's OpenGL parameters. You don't have to call this function, it is call when you do a draw.
void setClearStencilBufferAtDraw(bool clear)
Set if OpenGL stencil buffer will be cleared at draw.
Definition: GlScene.h:523
void removeLayer(const std::string &name, bool deleteLayer=true)
Remove the layer with name This GlLayer is automatically deleted If you want to keep this GlLayer you...
GlLayer * createLayer(const std::string &name)
Create a layer with the given name in the scene This layer is added to the layers list Now the scene ...
GlLayer * getLayer(const std::string &name)
Return the layer with name : name Return nullptr if the layer doesn't exist in the scene.
GlGraphComposite * getGlGraphComposite()
Return the current GlGraphComposite used by the scene.
Definition: GlScene.h:463
Color getBackgroundColor() const
Get the background color of the scene.
Definition: GlScene.h:316
bool isViewOrtho()
Scene is render in orthogonal mode ?
Definition: GlScene.h:330
void clearLayersList()
Clear layers list Layers will not be deleted in this function.
Definition: GlScene.h:416
void zoom(float factor, const Coord &dest)
Zoom to given world coordinate.
void setClearBufferAtDraw(bool clear)
Set if OpenGL buffer will be cleared at draw.
Definition: GlScene.h:495
void adjustSceneToSize(int width, int height)
void setClearDepthBufferAtDraw(bool clear)
Set if OpenGL depth buffer will be cleared at draw.
Definition: GlScene.h:509
const std::vector< std::pair< std::string, GlLayer * > > & getLayersList()
Return the layer list.
Definition: GlScene.h:408
GlLayer * createLayerBefore(const std::string &layerName, const std::string &beforeLayerWithName)
Create a layer with the given name in the scene just before layer with given name This layer is added...
void translateCamera(const int x, const int y, const int z)
Translate camera by (x,y,z)
void setGraphCamera(Camera *camera)
By default the most important layer is the layer where the graph is visualized This function set the ...
Definition: GlScene.h:487
bool getClearBufferAtDraw() const
If false, color buffer will not be cleared before drawing the scene.
Definition: GlScene.h:502
void zoom(int step)
Zoom by step.
Definition: GlScene.h:239
void removeLayer(GlLayer *layer, bool deleteLayer=true)
Remove the layer with name This GlLayer is automatically deleted If you want to keep this GlLayer you...
void draw()
Draw the scene This function is the most important function of GlScene. If you want to render a scene...
void computeAdjustSceneToSize(int width, int height, Coord *center, Coord *eye, float *sceneRadius, float *xWhiteFactor, float *yWhiteFactor, BoundingBox *sceneBoundingBox=nullptr, float *zoomFactor=nullptr)
GlLayer * createLayerAfter(const std::string &layerName, const std::string &afterLayerWithName)
Create a layer with the given name in the scene just after layer with given name This layer is added ...
Base class for all Tulip OpenGL entities.
The Observable class is the base of Tulip's observation system.
Definition: Observable.h:127
This class represents the 3D bounding box of an object. It is mostly used to determine whether or not...
Definition: BoundingBox.h:67
Structure to store selected entities.
Definition: GlScene.h:50
node getNode() const
Definition: GlScene.h:89
edge getEdge() const
Definition: GlScene.h:97
The edge struct represents an edge in a Graph object.
Definition: Edge.h:40
The node struct represents a node in a Graph object.
Definition: Node.h:40