Graph.cpp

Go to the documentation of this file.

//------------------------------------------------------------------------------

// Last Change: 2004/06/14
//     Version: 0.5

//---------------------------------------------------------------------includes-
#include <math.h>
#include "../src/Graph.h"
#include "../src/main.h"
#include "../src/Vector3D.h"

#define PI 3.14159265358979323846

//------------------------------------------------------------------createGraph-
//
// This creates a graph from a file.
// @param file_name The file name of the file which contains the graph to be
// build.
// @pre file_name != ""
//
void Graph::createGraph(char *file_name)
{
//=========================================================================TEST=
//
// It's just a test proposal.
// - Here we create a static Graph and test for displaying and other
// calculations.

//    // the test graph should have 6 nodes
//  Node *node_01 = new Node();
//  Node *node_02 = new Node();
//  Node *node_03 = new Node();
//  Node *node_04 = new Node();
//  Node *node_05 = new Node();
//  Node *node_06 = new Node();
//  Node *node_07 = new Node();
//  Node *node_08 = new Node();
//  Node *node_09 = new Node();
//  Node *node_10 = new Node();
//  Node *node_11 = new Node();
//    // set the node id's
//
//  node_01->setID(1);
//  node_02->setID(2);
//  node_03->setID(3);
//  node_04->setID(4);
//  node_05->setID(5);
//  node_06->setID(6);
//  node_07->setID(7);
//  node_08->setID(8);
//  node_09->setID(9);
//  node_10->setID(10);
//  node_11->setID(11);
//
//    // set caption of the nodes
//  node_01->setCaption(&string("1"));
//  node_02->setCaption(&string("2"));
//  node_03->setCaption(&string("3"));
//  node_04->setCaption(&string("4"));
//  node_05->setCaption(&string("5"));
//  node_06->setCaption(&string("6"));
//  node_07->setCaption(&string("7"));
//  node_08->setCaption(&string("8"));
//  node_09->setCaption(&string("9"));
//  node_10->setCaption(&string("10"));
//  node_11->setCaption(&string("11"));
//
//    // set the adjacents of the graph
//  node_01->setOneAdjacentNode(node_02);
//  node_02->setOneAdjacentNode(node_01);
//  node_02->setOneAdjacentNode(node_03);
//  node_03->setOneAdjacentNode(node_02);
//  node_03->setOneAdjacentNode(node_04);
//  node_04->setOneAdjacentNode(node_03);
//  node_04->setOneAdjacentNode(node_05);
//  node_04->setOneAdjacentNode(node_06);
//  node_05->setOneAdjacentNode(node_04);
//  node_06->setOneAdjacentNode(node_04);
//
//  node_07->setOneAdjacentNode(node_08);
//  node_07->setOneAdjacentNode(node_01);
//  node_01->setOneAdjacentNode(node_07);
//  node_08->setOneAdjacentNode(node_07);
//  node_08->setOneAdjacentNode(node_09);
//  node_09->setOneAdjacentNode(node_08);
//  node_10->setOneAdjacentNode(node_03);
//  node_03->setOneAdjacentNode(node_10);
//
//  node_09->setOneAdjacentNode(node_11);
//  node_11->setOneAdjacentNode(node_09);
//
//    // insert all nodes into nodes list
//  setOneNodeIntoGraph(node_01);
//  setOneNodeIntoGraph(node_02);
//  setOneNodeIntoGraph(node_03);
//  setOneNodeIntoGraph(node_04);
//  setOneNodeIntoGraph(node_05);
//  setOneNodeIntoGraph(node_06);
//  setOneNodeIntoGraph(node_07);
//  setOneNodeIntoGraph(node_08);
//  setOneNodeIntoGraph(node_09);
//  setOneNodeIntoGraph(node_10);
//  setOneNodeIntoGraph(node_11);

//
//=========================================================================TEST=

//========================================================================TEST2=
//

    // the test graph should have 68 nodes
  Node *node_01 = new Node();
  Node *node_02 = new Node();
  Node *node_03 = new Node();
  Node *node_04 = new Node();
  Node *node_05 = new Node();
  Node *node_06 = new Node();
  Node *node_07 = new Node();
  Node *node_08 = new Node();
  Node *node_09 = new Node();
  Node *node_10 = new Node();
  Node *node_11 = new Node();
  Node *node_12 = new Node();
  Node *node_13 = new Node();
  Node *node_14 = new Node();
  Node *node_15 = new Node();
  Node *node_16 = new Node();
  Node *node_17 = new Node();
  Node *node_18 = new Node();
  Node *node_19 = new Node();
  Node *node_20 = new Node();
  Node *node_21 = new Node();
  Node *node_22 = new Node();
  Node *node_23 = new Node();
  Node *node_24 = new Node();
  Node *node_25 = new Node();
  Node *node_26 = new Node();
  Node *node_27 = new Node();
  
    // set caption of the nodes
  node_01->setCaption("1");
  node_02->setCaption("2");
  node_03->setCaption("3");
  node_04->setCaption("4");
  node_05->setCaption("5");
  node_06->setCaption("6");
  node_07->setCaption("7");
  node_08->setCaption("8");
  node_09->setCaption("9");
  node_10->setCaption("10");
  node_11->setCaption("11");
  node_12->setCaption("12");
  node_13->setCaption("13");
  node_14->setCaption("14");
  node_15->setCaption("15");
  node_16->setCaption("16");
  node_17->setCaption("17");
  node_18->setCaption("18");
  node_19->setCaption("19");
  node_20->setCaption("20");
  node_21->setCaption("21");
  node_22->setCaption("22");
  node_23->setCaption("23");
  node_24->setCaption("24");
  node_25->setCaption("25");
  node_26->setCaption("26");
  node_27->setCaption("27");
  
    // set ID of the nodes
  node_01->setID(1);
  node_02->setID(2);
  node_03->setID(3);
  node_04->setID(4);
  node_05->setID(5);
  node_06->setID(6);
  node_07->setID(7);
  node_08->setID(8);
  node_09->setID(9);
  node_10->setID(10);
  node_11->setID(11);
  node_12->setID(12);
  node_13->setID(13);
  node_14->setID(14);
  node_15->setID(15);
  node_16->setID(16);
  node_17->setID(17);
  node_18->setID(18);
  node_19->setID(19);
  node_20->setID(20);
  node_21->setID(21);
  node_22->setID(22);
  node_23->setID(23);
  node_24->setID(24);
  node_25->setID(25);
  node_26->setID(26);
  node_27->setID(27);

    // insert all nodes into nodes list
  setOneNodeIntoGraph(node_01);
  setOneNodeIntoGraph(node_02);
  setOneNodeIntoGraph(node_03);
  setOneNodeIntoGraph(node_04);
  setOneNodeIntoGraph(node_05);
  setOneNodeIntoGraph(node_06);
  setOneNodeIntoGraph(node_07);
  setOneNodeIntoGraph(node_08);
  setOneNodeIntoGraph(node_09);
  setOneNodeIntoGraph(node_10);
  setOneNodeIntoGraph(node_11);
  setOneNodeIntoGraph(node_12);
  setOneNodeIntoGraph(node_13);
  setOneNodeIntoGraph(node_14);
  setOneNodeIntoGraph(node_15);
  setOneNodeIntoGraph(node_16);
  setOneNodeIntoGraph(node_17);
  setOneNodeIntoGraph(node_18);
  setOneNodeIntoGraph(node_19);
  setOneNodeIntoGraph(node_20);
  setOneNodeIntoGraph(node_21);
  setOneNodeIntoGraph(node_22);
  setOneNodeIntoGraph(node_23);
  setOneNodeIntoGraph(node_24);
  setOneNodeIntoGraph(node_25);
  setOneNodeIntoGraph(node_26);
  setOneNodeIntoGraph(node_27);

    // set the adjacents of the graph
  node_01->setOneAdjacentNode(node_08);
  node_08->setOneAdjacentNode(node_01);
  node_02->setOneAdjacentNode(node_10);
  node_10->setOneAdjacentNode(node_02);
  node_03->setOneAdjacentNode(node_10);
  node_10->setOneAdjacentNode(node_03);
  node_04->setOneAdjacentNode(node_13);
  node_13->setOneAdjacentNode(node_04);
  node_05->setOneAdjacentNode(node_13);
  node_13->setOneAdjacentNode(node_05);
  node_06->setOneAdjacentNode(node_13);
  node_13->setOneAdjacentNode(node_06);

  node_07->setOneAdjacentNode(node_18);
  node_18->setOneAdjacentNode(node_07);
  node_08->setOneAdjacentNode(node_18);
  node_18->setOneAdjacentNode(node_08);
  node_09->setOneAdjacentNode(node_19);
  node_19->setOneAdjacentNode(node_09);
  node_10->setOneAdjacentNode(node_19);
  node_19->setOneAdjacentNode(node_10);
  node_11->setOneAdjacentNode(node_19);
  node_19->setOneAdjacentNode(node_11);
  node_12->setOneAdjacentNode(node_20);
  node_20->setOneAdjacentNode(node_12);
  node_13->setOneAdjacentNode(node_20);
  node_20->setOneAdjacentNode(node_13);
  node_14->setOneAdjacentNode(node_22);
  node_22->setOneAdjacentNode(node_14);
  node_15->setOneAdjacentNode(node_22);
  node_22->setOneAdjacentNode(node_15);
  node_16->setOneAdjacentNode(node_22);
  node_22->setOneAdjacentNode(node_16);
  node_17->setOneAdjacentNode(node_22);
  node_22->setOneAdjacentNode(node_17);

  node_18->setOneAdjacentNode(node_24);
  node_24->setOneAdjacentNode(node_18);
  node_19->setOneAdjacentNode(node_24);
  node_24->setOneAdjacentNode(node_19);
  node_20->setOneAdjacentNode(node_25);
  node_25->setOneAdjacentNode(node_20);
  node_21->setOneAdjacentNode(node_25);
  node_25->setOneAdjacentNode(node_21);
  node_22->setOneAdjacentNode(node_25);
  node_25->setOneAdjacentNode(node_22);
  node_23->setOneAdjacentNode(node_26);
  node_26->setOneAdjacentNode(node_23);
  node_24->setOneAdjacentNode(node_27);

  node_27->setOneAdjacentNode(node_24);
  node_25->setOneAdjacentNode(node_27);
  node_27->setOneAdjacentNode(node_25);
  node_26->setOneAdjacentNode(node_27);
  node_27->setOneAdjacentNode(node_26);

//
//========================================================================TEST2=
    // make a deep copy of the graph
  makeDeepCopyOfGraph(&nodes_copy_);

  makeDeepCopyOfGraph(&nodes_end_pos_);
    // clear all nodes
  getCentreNodeOfGraph(&nodes_copy_);

  vector<Node*>::iterator iter = nodes_.begin();
  int count = 0;
  while (iter != nodes_.end())
  {
//    cout << count << endl;
    count++;
    if ((*iter)->getID() == nodes_copy_.at(0)->getID())
    {
      break;
    }
    ++iter;
  }
    // the real graph centre!!
  centroid_ = (*iter);
//  cout << "GRAPH-CENTRE: " << centroid_->getID() << endl;
    // set the start position of the centroid and the node wich has the most
    // number of leafs in it's sub-tree
  (*iter)->setPointVector(new Vector3D(0.0f, 0.0f, 0.0f, 0.0f));

    // the centroid will recieve the whole angular width available
  (*iter)->setAngularWidth(360.0f);

    // calcualte the angular widths for all nodes in the graph: firstly we take
    // all nodes with degree 1 and propagate +1 to other adjacent nodes
    //calcAngularWidths(&nodes_);
   updateNumOfLeafs(&nodes_);

  radial_layout_->initRadiusOfRings(10);
  initStartPositions(*iter, *iter);

  calcCartesianCoordinates(&nodes_);
}

//----------------------------------------------------------makeDeepCopyOfGraph-
//
// This copies (really) all elemens of a graph.
//
void Graph::makeDeepCopyOfGraph(vector<Node*> *nodes_copy)
{
  vector<Node*>::iterator iter_old = nodes_.begin();
    // go through the old graph and assign the "same" Nodes (i.e. copies) to the
    // copied graph
  while (iter_old != nodes_.end())
  {
    nodes_copy->push_back(new Node(*iter_old));
    ++iter_old;
  }

    // go through the adjacent list and link each adjacent node with the one
  iter_old = nodes_.begin();
  vector<Node*>::iterator iter_new = nodes_copy->begin();
  while (iter_new != nodes_copy->end())
  {
    vector<Node*>::iterator iter_adj =
      (*iter_old)->getListOfAdjacentNodes()->begin();
      // copy the adjacent list
    while (iter_adj != (*iter_old)->getListOfAdjacentNodes()->end())
    {
        // this loop goes through the copied nodes vector and searches for the
        // right adjacent node
      vector<Node*>::iterator iter_new_2 = nodes_copy->begin();
      while (iter_new_2 != nodes_copy->end())
      {
        if ((*iter_adj)->getID() == (*iter_new_2)->getID())
        {
          (*iter_new)->setOneAdjacentNode(*iter_new_2);
        }
        ++iter_new_2;
      }
      ++iter_adj;
    }
    ++iter_old;
    ++iter_new;
  }

  vector<Node*>::iterator iter_new_3 = nodes_copy->begin();
  while (iter_new_3 != nodes_copy->end())
  {
    vector<Node*>::iterator iter_adj_2 =
      (*iter_new_3)->getListOfAdjacentNodes()->begin();
    while (iter_adj_2 != (*iter_new_3)->getListOfAdjacentNodes()->end())
    {
      ++iter_adj_2;
    }
    cout << endl;
    ++iter_new_3;
  }
}

//---------------------------------------------------------getCentreNodeOfGraph-
//
// This finds the longest path of the graph and returns the centred node. We are
// using the simple algorithm on @link
// http://www.personal.kent.edu/~rmuhamma/GraphTheory/MyGraphTheory/trees.htm
// @param nodes The list of nodes.
// @pre nodes_ != empty
//
void Graph::getCentreNodeOfGraph(vector<Node*> *nodes)
{
    // We go through the adjacents list and check whether a node has a degree
    // 1. If so we delete him.
  vector<Node*>::iterator iter_1 = nodes->begin();
  vector<Node*> temp_nodes;
    // this loop findes all nodes in current 'nodes'-vector with degree 1
    // which will be deleted
  while (iter_1 != nodes->end())
  {
    if ((*iter_1)->getDegree() == 1)
    {
        // store the nodes with degree 1 at current iteration 
      temp_nodes.push_back(*iter_1);
    }
    ++iter_1;
  }
  vector<Node*>::iterator iter_2 = temp_nodes.begin();
    // this loop deletes all nodes with degree 1 for one iteration
  while (iter_2 != temp_nodes.end())
  {
    iter_1 = nodes->begin();
    while (iter_1 != nodes->end())
    {
        // leave at least one node in array 'nodes'
      if ((*iter_1 == *iter_2) & (nodes->size() != 1))
      {
          // erase the current node out of the graph (i.e. so that there will be
          // no other link to this node)
        (*iter_1)->eraseNode(*iter_1);
          // erase the current node with degree 1
        nodes->erase(iter_1);
        --iter_1;
      }
      ++iter_1;
    }
    ++iter_2;
  }

  if (nodes->size() != 1)
  {
    getCentreNodeOfGraph(nodes);
  }
}

//----------------------------------------------------------setOneNodeIntoGraph-
//
// This sets one node into the graph.
// @param node The node to set.
//
void Graph::setOneNodeIntoGraph(Node *node)
{
  nodes_.push_back(node);
}

//-----------------------------------------------------------initStartPositions-
//
// This initializes the start positions of the nodes.
// @param centroid The centroid of the graph.
//
void Graph::initStartPositions(Node *centroid, Node *predecessor)
{
    //        90
    //       --|--
    //      /  |  \
    // 180 |-------| 0=360
    //      \  |  /
    //       --|--
    //        270

    // sum the number of leafs which are reachable from the root
  GLuint overall_num_leafs = 0;
  vector<GLuint>::iterator iter_leaf =
    (centroid->getListOfLeafeNodes())->begin();
  vector<Node*>::iterator iter = (centroid->getListOfAdjacentNodes())->begin();
  while (iter_leaf != (centroid->getListOfLeafeNodes())->end())
  {
    if ((*iter)->getID() != predecessor->getID())
    {
      overall_num_leafs += (*iter)->getNumLeafs(centroid);
    }
    ++iter_leaf;
    ++iter;
  }

    // set radius of the ring to the centroid
  centroid->setRing(num_ring_);
  GLfloat radius = radial_layout_->getRadiusOfRing(num_ring_);
  centroid->setRadius(radius);

    // go through the adjacent list and assign the angular width to each
    // neighbour
    // find the node with the most number of leafs in it's sub-tree and
    // re-orientate others on that node
  vector<Node*>::iterator iter_greatest_angular_width =
    (centroid->getListOfAdjacentNodes())->begin();

    // initialize one element so that the following elements do have an starting
    // orientation
  iter = (centroid->getListOfAdjacentNodes())->begin();
  iter_leaf = (centroid->getListOfLeafeNodes())->begin();
  while (iter != (centroid->getListOfAdjacentNodes())->end())
  {
    if ((*iter)->getID() != predecessor->getID())
    {
      GLfloat temp = (*iter)->getNumLeafs(centroid); // DON'T FORGET!!
      GLfloat ang_width = (temp / overall_num_leafs) *
                          (centroid->getAngularWidth());
      (*iter)->setAngularWidth(ang_width);

      if (ang_width > (*iter_greatest_angular_width)->getAngularWidth())
      {
        ++iter_greatest_angular_width;
      }
    }
    ++iter_leaf;
    ++iter;
  }
  
    // set the angle of the centroid
  centroid->setAngle((centroid->getAngularWidth() / 2)
                     + centroid->getAngleOffset());

    // go through the adjacent list and assignt the angle values to each node
  iter = (centroid->getListOfAdjacentNodes())->begin();
  GLfloat curr_angle = 0;
  while (iter != (centroid->getListOfAdjacentNodes())->end())
  {
    if ((*iter)->getID() != predecessor->getID())
    {
      (*iter)->addAngleOffset(centroid->getAngleOffset());
      ++num_ring_;
      initStartPositions(*iter, centroid);
      --num_ring_;
    }
    ++iter;
  }
  predecessor->addAngleOffset(centroid->getAngularWidth());

  if (centroid->getID() == predecessor->getID())
  {
    centroid->setAngle(0.0f);
    return;
  }
}

//-------------------------------------------------------------updateNumOfLeafs-
//
// This assigns the right number of the leafs which are reachable from a given
// node.
// @param node The node from which we want to reach the leafs.
//
void Graph::updateNumOfLeafs(vector<Node*> *nodes)
{
    // the number of leafs for current subtree: find the number of nodes with
    // degree 1 (i.e. a leaf)
  vector<Node*>::iterator iter = nodes->begin();
  while (iter != nodes->end())
  {
      // update the angular width
    if ((*iter)->getDegree() == 1)
    {
      (*iter)->incrNumOfLeafs(*iter);
    }
    ++iter;
  }
}
//-----------------------------------------------------calcCartesianCoordinates-
//
// This calculates the Cartesian coordinates.
// @param nodes The nodes to calculate the Cartesian coordinates.
//
void Graph::calcCartesianCoordinates(vector<Node*> *nodes)
{
    // convert polar coordinates into cartesian coordinates
  vector<Node*>::iterator iter = nodes->begin();
  while (iter != nodes->end())
  {
    GLfloat x_coord = 0;
    GLfloat y_coord = 0;
    x_coord = (*iter)->getRadius() * cos((PI / 180) * (*iter)->getAngle());
    y_coord = (*iter)->getRadius() * sin((PI / 180) * (*iter)->getAngle());

    (*iter)->setPointVector(new Vector3D(x_coord, y_coord, 0.0f, 0.0f));
    ++iter;
  }
}

//---------------------------------------------------------------------drawNode-
//
// This draws the graph into an OpenGL viewport.
// @param quadric The quadric which represents the nodes for drawing.
//
void Graph::drawGraph(GLUquadricObj *quadric)
{
  calcCartesianCoordinates(&nodes_);
      // convert to cartesian coordinates
  GLfloat mat_ambient[]    = {0.0f,  0.0f,  1.0f, 1.0f};
  GLfloat mat_diffuse[]    = {0.0f,  0.0f,  0.8f, 1.0f};
  GLfloat light_position[] = {0.0f, -1.0f, -1.0f, 1.0};
  GLfloat shininess[]      = {0.5f};
  
  glMaterialfv( GL_FRONT,  GL_AMBIENT,   mat_ambient);
  glMaterialfv( GL_FRONT,  GL_DIFFUSE,   mat_diffuse);
  glMaterialfv( GL_FRONT,  GL_SHININESS, shininess);
  glLightfv(GL_LIGHT0, GL_POSITION,  light_position);

  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_COLOR_MATERIAL);

    // draw lines first
  glPushMatrix();
  drawLine();
  glPopMatrix();

  if (last_animation_speed_ - (*animation_speed_) != 0)
  {
    node_animation_->setNodeAnimationSpeed(animation_speed_);
    last_animation_speed_ = (*animation_speed_);
    num_iterations_ = 1;
  }

  vector<Node*>::iterator iter = nodes_.begin();
  vector<Node*>::iterator iter_2 = nodes_end_pos_.begin();
  while (iter != nodes_.end())
  {
    glLoadName((*iter)->getID());
    glBegin(GL_LINES);
    glEnd();
    (*iter)->setSceneRotation(x_rotation_, y_rotation_, z_rotation_);
    if (is_animation_running_ == true)
    {
        // getNewEndRadius, getNewEndAngle
      node_animation_->interpolatePolarCoord((*iter), (*iter_2)->getRadius(),
                                             (*iter_2)->getAngle(),
                                             num_iterations_);
      node_animation_->calculateNodeRadiusAndColor((*iter),
                                                   (*iter)->getRadius());
    }
    else
    {
      node_animation_->calculateNodeRadiusAndColor((*iter),
                                                   (*iter)->getRadius());
    }
    glPushMatrix();
    (*iter)->drawNode(quadric, render_mode_, caption_mode_);
    glPopMatrix();
    glEnd();
    ++iter;
    ++iter_2;
  }
}

//---------------------------------------------------------------------drawLine-
// 
// This draws the Lines between the adjacent nodes.
//
void Graph::drawLine()
{
  vector<Node*>::iterator iter_1 = nodes_.begin();
  while (iter_1 != nodes_.end())
  {
    GLfloat x = (*iter_1)->getPointVector()->getXCoord();
    GLfloat y = (*iter_1)->getPointVector()->getYCoord();

    vector<Node*>::iterator iter_2 =
      (*iter_1 )->getListOfAdjacentNodes()->begin();
    while (iter_2 != (*iter_1 )->getListOfAdjacentNodes()->end())
    {
      GLfloat x_adj = (*iter_2)->getPointVector()->getXCoord();
      GLfloat y_adj = (*iter_2)->getPointVector()->getYCoord();
      glColor4f(0.6f, 0.8f, 1.0f, 0.5f);
      glEnable(GL_BLEND);
      glLineWidth(1.0f);

      glBegin(GL_LINES);
      glVertex3f(x, y, 0.0);
      glVertex3f(x_adj, y_adj, 0.0);
      glEnd();
      glLineWidth(1.0f);
      glDisable(GL_BLEND);
      glColor3f(0.0f, 0.0f, 0.0f);
      ++iter_2;
    }
    ++iter_1;
  }
}

//----------------------------------------------------------------setCenterNode-
//
// This sets the selected node as the new focud node.
// @param center_node The node which was select from the user to be the center
// of the graph.
//
void Graph::setCenterNode(GLuint id)
{
  vector<Node*>::iterator iter = nodes_.begin();
  while (iter != nodes_.end())
  {
    if ((*iter)->getID() == id)
    {
      centroid_ = (*iter);
    }
    ++iter;
  }
}

//----------------------------------------------------------------isNodeClicked-
//
// Checks wether a graph's node has been selected.
// @return Returns true if a node of the graph has been selected.
//
bool Graph::isANodeClicked(GLuint object_id)
{
  bool return_flag = false;
  vector<Node*>::iterator iter = nodes_.begin();

  iter = nodes_end_pos_.begin();
  while (iter != nodes_end_pos_.end())
  {
    if ((*iter)->getID() == object_id)
    {
        // reset all relevant member variables of each node to default values
      vector<Node*>::iterator iter_2 = nodes_end_pos_.begin();
      while (iter_2 != nodes_end_pos_.end())
      {
        (*iter_2)->resetMembers();
        ++iter_2;
      }

      (*iter)->setPointVector(new Vector3D(0.0f, 0.0f, 0.0f, 0.0f));
      (*iter)->setAngularWidth(360.0f);
      updateNumOfLeafs(&nodes_end_pos_);
      num_ring_ = 0;

      initStartPositions((*iter), (*iter));
      calcCartesianCoordinates(&nodes_end_pos_);
      return_flag = true;
      break;
    }
    ++iter;
  }

  if (return_flag == true)
  {
    return(true);
  }
  else
  {
    return(false);
  }
}

//-------------------------------------------------------------resetAngleOffset-
//
// Resets the angle offset of each node to the specified value.
// @param nodes The graph which nodes' angle offset has to be set.
// @param angle_offset The angle offset to set for each node of the graph.
//
void Graph::resetAngleOffsetTo(vector<Node*> *nodes, GLfloat angle_offset)
{
  vector<Node*>::iterator iter = nodes->begin();
  while (iter != nodes->end())
  {
    GLfloat curr_angle_offset = (*iter)->getAngleOffset();
    (*iter)->addAngleOffset(-curr_angle_offset + angle_offset);
    ++iter;
  }
}

//------------------------------------------------------highlightNodeIfSelected-
//
// Highlights the node with the given ID if the node has been selected.
// @param node_id The ID of the node.
//
void Graph::highlightNodeIfSelected(GLuint node_id)
{
  vector<Node*>::iterator iter = nodes_.begin();
  while (iter != nodes_.end())
  {
      // set all other nodes not-selected
    (*iter)->setSelected(false);
    if ((*iter)->getID() == node_id)
    {
      (*iter)->setSelected(true);
    }
    ++iter;
  }
}

//-------------------------------------------------------------setAnimationMode-
void Graph::setAnimationMode(bool animation_mode)
{
  animation_mode_ = animation_mode;
  if (animation_mode_ == true)
  {
    GLint random_center = (GLint)(rand()% nodes_.size());
    if (random_center != 0)
    {
      cout <<"New Centroid: " << random_center << endl;
      highlightNodeIfSelected(random_center);
      isANodeClicked(random_center);
      setCenterNode(random_center);
    }
  }
}

//------------------------------------------------------------toggleRenderMode-
//
// This sets the render mode.
//
void Graph::toggleRenderMode()
{
  render_mode_ == true ? render_mode_ = false : render_mode_ = true;
}

//------------------------------------------------------------toggleCaptionMode-
void Graph::toggleCaptionMode()
{
  caption_mode_ == true ? caption_mode_ = false : caption_mode_ = true;
}

//-----------------------------------------------------------setAnimationSpeed-
//
// This sets the animation speed.
// @paran animation_speed The speed of the node animation.
//
void Graph::setAnimationSpeed(GLuint *animation_speed)
{
  animation_speed_ = animation_speed;
}

//------------------------------------------------------------setRotaionOfScene-
//
// This sets the current rotation of the entire scene.
// @param x_rotation The rotation along the x axis.
// @param y_rotation The rotation along the y axis.
// @param z_rotation The rotation along the z axis.
//
void Graph::setSceneRotation(GLfloat x_rotation, GLfloat y_rotation,
                             GLfloat z_rotation)
{
  x_rotation_ = x_rotation;
  y_rotation_ = y_rotation;
  z_rotation_ = z_rotation;
}

// eof

---