Node.cpp

Go to the documentation of this file.

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

// Last Change: 2004/06/11
//     Version: 0.4

//---------------------------------------------------------------------includes-
#include "../src/main.h"
#include "../src/Node.h"

//---------------------------------------------------------operator overloading-
//
// This compares two nodes and returns 0 if they are not equal (member wise)
// and 1 else.
// @return Returns 0 if two nodes aren't equal and 0 else.
//
int Node::operator==(Node &to_compare_node)
{
    // we assume that every node has a distinct caption !!
  if (id_ == to_compare_node.getID())
  {
    return(1);
  }
  return(0);
}

//------------------------------------------------------------------------setID-
//
// This sets the ID of one node.
// @param id The ID of the node.
//
void Node::setID(GLuint id)
{
  id_ = id;
}

//------------------------------------------------------------------------getID-
//
// This returns the ID of one node.
// @returns id The ID of the node.
//
GLuint Node::getID()
{
  return (id_);
}

//-------------------------------------------------------------------setCaption-
//
// This sets the caption of the node.
// @param caption The caption to set.
//
void Node::setCaption(char const *caption)
{
  caption_ = reinterpret_cast<char const*>(caption);
}

//-------------------------------------------------------------------getID-
//
// This returns the caption of the node.
// @return Returns the cpation of the node.
//
char const *Node::getCaption()
{
  return(caption_);
}

//---------------------------------------------------------------setPointVector-
//
// This sets point vector which indicates the position of the node in the
// space.
// @param point_vector The point vector of the node.
//
void Node::setPointVector(Vector3D *point_vector)
{
  if (point_vector_ != NULL)
  {
    delete(point_vector_);
  }
  point_vector_ = point_vector;
}

//---------------------------------------------------------------getPointVector-
//
// This returns the point vector which indicates the position of the node in
// the space.
// @return Returs the point vector of the node.
//
Vector3D *Node::getPointVector() const
{
  return(point_vector_);
}

//--------------------------------------------------------------setAngularWidth-
//
// This sets the angular width for the node.
// @param angular_width The angular width to set.
//
void Node::setAngularWidth(GLfloat angular_width)
{
  angular_width_ = angular_width;
}

//--------------------------------------------------------------getAngularWidth-
//
// This returns the angular width for the node.
// @return The angular width.
//
GLfloat Node::getAngularWidth()
{
  return(angular_width_);
}

//----------------------------------------------------------------------setRing-
//
// This sets the ring number.
// @param ring The ring number.
//
void Node::setRing(GLuint ring_number)
{
  ring_number_ = ring_number;
}

//----------------------------------------------------------------------getRing-
//
// This returns the ring on which the node is sitting on.
// @return The ring.
//
GLuint Node::getRing() const
{
  return(ring_number_);
}

//-----------------------------------------------------------setOneAdjacentNode-
//
// This sets one adjacent node to this node.
// @param node The adjacent node to set.
//
void Node::setOneAdjacentNode(Node *node)
{
  adjacents_.push_back(node);
    // initialize the number of leafs when node is connected with the graph
  num_leafs_.push_back(0);
}

//--------------------------------------------------------deleteOneAdjacentNode-
//
// This deletes one adjacent node.
// @param node The adjacent node to delet.
//
void Node::deleteOneAdjacentNode(Node *node)
{
  vector<Node*>::iterator iter = adjacents_.begin();
  while (iter != adjacents_.end())
  {
    if ((*iter) == node)
    {
      adjacents_.erase(iter);
      break;
    }
    ++iter;
  }
}

//-------------------------------------------------------getListOfAdjacentNodes-
//
// This returns the list (i.e. vector) of adjacent nodes.
// @return The list of adjacent nodes.
//
vector<Node*> *Node::getListOfAdjacentNodes()
{
  return(&adjacents_);
}

//----------------------------------------------------------getListOfLeafeNodes-
//
// This returns the list (i.e. vector) of adjacent nodes.
// @return The list of adjacent nodes.
//
vector<GLuint> *Node::getListOfLeafeNodes()
{
  return(&num_leafs_);
}

//--------------------------------------------------------------------getDegree-
//
// This returns the degree of the node.
// @return The degree of the node.
//
GLuint Node::getDegree()
{
  return((GLuint)adjacents_.size());
}

//--------------------------------------------------------------incrNumOfLeafs-
//
// This increments the number of leafs which are reachable from this node coming
// from the specified node (see parameter).
// @param root The root of the sub-tree.
//
void Node::incrNumOfLeafs(Node *root)
{
  vector<Node*>::iterator iter_1 = adjacents_.begin();
  vector<GLuint>::iterator iter_2 = num_leafs_.begin();
  GLuint index = 0;
  while (iter_1 != adjacents_.end())
  {
    GLuint num_leafs = (*iter_2);
    if (((*iter_1)->getID() != root->getID()))
//        && ((*iter_1)->getLastVisitor() != id_))
    {
      num_leafs_[index] = ++num_leafs;
      last_visitor_ = root->getID();
      (*iter_1)->incrNumOfLeafs(this);
    }
    ++index;
    ++iter_1;
    ++iter_2;
  }
}

//-----------------------------------------------------------------getNumLeafs-
//
// This returns the number of leafs for the corresponding Node in the adjacent
// nodes list.
// @return The number of leafs.
//
GLuint Node::getNumLeafs(Node *node)
{
  vector<Node*>::iterator iter_1 = adjacents_.begin();
  vector<GLuint>::iterator iter_2 = num_leafs_.begin();
  while (iter_1 != adjacents_.end())
  {
    if (node->getID() == (*iter_1)->getID())
    {
      break;
    }
    ++iter_1;
    ++iter_2;
  }
  return(*iter_2);
}

//------------------------------------------------getTotalNumOfLeafsExceptRoot-
//
// This returns the number of leafs for the corresponding Node in the adjacent
// nodes list and excludes the root.
// @return The number of leafs.
//
GLuint Node::getTotalNumOfLeafsExceptRoot(Node *root)
{
  vector<Node*>::iterator iter_1 = adjacents_.begin();
  vector<GLuint>::iterator iter_2 = num_leafs_.begin();
  GLuint num_leafs = 0;
  while (iter_1 != adjacents_.end())
  {
    if (root->getID() != (*iter_1)->getID())
    {
      num_leafs += *iter_2;
    }
    ++iter_1;
    ++iter_2;
  }
  return(num_leafs);
}

//--------------------------------------------------------------------eraseNode-
//
// This erases this node. That means that every link to this node is going to be
// erased.
//
void Node::eraseNode(Node *node)
{
  vector<Node*>::iterator iter_1 = adjacents_.begin();
  vector<Node*>::iterator iter_2;

  while (iter_1 != adjacents_.end())
  {
    iter_2 = (((*iter_1)->getListOfAdjacentNodes()))->begin();
    while (iter_2 != ((*iter_1)->getListOfAdjacentNodes())->end())
    {
      if (((*iter_2)->getID()) == (node->getID()))
      {
        ((*iter_1)->getListOfAdjacentNodes())->erase(iter_2);
        --iter_2;
      }
      ++iter_2;
    }
    iter_1++;
  }
}

//---------------------------------------------------------------------drawNode-
//
// This draws the node into an OpenGL viewport.
// @param quadric The quadric which represents the node for drawing.
// @param render_mode The render mode of the quardric.
// @param render_mode The caption mode of the quardric.
//
void Node::drawNode(GLUquadricObj *quadric, bool render_mode, bool caption_mode)
{
    // set material and light  properties
  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,  0.0f,  -1.0f, 1.0f};
  GLfloat shininess[]      = {0.5f};

  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  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);

  // enable light and material color
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_COLOR_MATERIAL);
  glEnable(GL_LINE_SMOOTH);
  
  if (render_mode == true)
  {
    glEnable(GL_BLEND);
    glColor4f(red_, green_, blue_, 0.3f);
  }
  else
  {
    glDisable(GL_BLEND);
    glColor4ub(red_, green_, blue_, 1);
  }
  glTranslated(point_vector_->getXCoord(), point_vector_->getYCoord(), 0.0);

  glPushMatrix();
  gluQuadricNormals(quadric, GLU_SMOOTH);
  gluQuadricDrawStyle(quadric, GLU_FILL);
  gluSphere(quadric, node_radius_, 50, 50);
  glPopMatrix();
  if (is_selected_ == true)
  {
//     glRotatef(-z_rotation_, 0.0f, 0.0f, 1.0f);
//     glRotatef(-y_rotation_, 0.0f, 1.0f, 0.0f);
//     glRotatef(-x_rotation_, 1.0f, 0.0f, 0.0f);

    glDisable(GL_BLEND);
    glDisable(GL_LIGHTING);
    glDisable(GL_LIGHT0);
    glDisable(GL_COLOR_MATERIAL);
    glColor3f(0.0f, 1.0f, 0.0f);
    gluQuadricNormals(quadric, GLU_SMOOTH);
    gluQuadricDrawStyle(quadric, GLU_FILL);
    glLineWidth(1.5f);
//    gluSphere(quadric, node_radius_ + 0.02, 50, 50);
    gluDisk(quadric, node_radius_, node_radius_ + 0.02, 200, 1);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_COLOR_MATERIAL);
    glColor3f(1.0f, 1.0f, 1.0f);
    glLineWidth(1.0f);
    glEnable(GL_BLEND);
  }

  gluQuadricNormals(quadric, GLU_SMOOTH);

  if (caption_mode)
  {
    glPushMatrix();
      // Disable lighting while we render text
    if (render_mode == true)
    {
      glDisable(GL_LIGHTING);
      glColor3ub(255, 255, 255);
      glDisable(GL_BLEND);
    }
    else
    {
      glDisable(GL_LIGHTING);
      glColor3ub(255, 255, 0);
    }
    glRasterPos3f(point_vector_->getXCoord()/100 - 0.04,
                  point_vector_->getYCoord()/100 - 0.04, 0.0f);

      // render the live character array 'text'
    for(int curr_character = 0;
        curr_character < (int)strlen(caption_);
        ++curr_character)
    {
      glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18,
                          caption_[curr_character]);
    }
    glPopMatrix();
  }

  // disable light and material color
  glDisable(GL_LIGHTING);
  glDisable(GL_LIGHT0);
  glDisable(GL_COLOR_MATERIAL);
  glDisable(GL_LINE_SMOOTH);

  if (render_mode == true)
  {
    glDisable(GL_BLEND);
  }
}

//----------------------------------------------------------------------setAngle-
//
// This sets the angle of one node
// @param polar_phi_ The phi angle of the node
//
void Node::setAngle(GLfloat polar_phi)
{
  polar_phi_ = polar_phi;
}

//----------------------------------------------------------------------getAngle-
//
// This returns the angle of one node
// @return Returns The phi angle of the node
//
GLfloat Node::getAngle() const
{
  return(polar_phi_);
}

//---------------------------------------------------------------------getRadius-
//
// This sets the radius of one node
// @param ring_radius_ The node/ring
//
void Node::setRadius(GLfloat ring_radius)
{
  ring_radius_ = ring_radius;
}

//---------------------------------------------------------------------setRadius-
//
// This returns the radius of one node
// @return Returns The radius of the node
//
GLfloat Node::getRadius() const
{
  return(ring_radius_);
}

//-----------------------------------------------------------------------setRed-
//
// This sets the color of one node
// @param red The red part of the RGB color.
//
void Node::setRed(GLuint red)
{
  red_ = red;
}

//----------------------------------------------------------------------setGreen-
//
// This sets the color of one node
// @param green The green part of the RGB color.
//
void Node::setGreen(GLuint green)
{
  green_ = green;
}

//----------------------------------------------------------------------setBlue-
//
// This sets the color of one node
// @param blue The blue part of tehe RGB color.
//
void Node::setBlue(GLuint blue)
{
  blue_ = blue;
}

//-----------------------------------------------------------------------getRed-
//
// This returns the red part of tehe RGB color of one node.
// @return red Returns the red part of the RGB color.
//
GLuint Node::getRed() 
{
  return(red_);
}

//---------------------------------------------------------------------getGreen-
//
// This returns the green part of tehe RGB color of one node.
// @return red Returns the green part of tehe RGB color.
//
GLuint Node::getGreen()
{
  return(green_);
}

//----------------------------------------------------------------------getBlue-
//
// This returns the blue part of tehe RGB color of one node.
// @return red Returns the blue part of tehe RGB color.
//
GLuint Node::getBlue()
{
  return(blue_);
}

//----------------------------------------------------------------setNodeRadius-
//
// This sets the radius of one node,
// @param ring_radius_ The node/ring
//
void Node::setNodeRadius(GLfloat node_radius)
{
  node_radius_ = node_radius;
}

//----------------------------------------------------------------getNodeRadius-
//
// This returns the radius of one node.
// @return Returns The radius of the node
//
GLfloat Node::getNodeRadius() const
{
  return(node_radius_);
}

//---------------------------------------------------------------setLastVisitor-
//
// This sets the last visitor root.
// @param last_visitor The last visitor root to set.
//
void Node::setLastVisitor(GLint last_visitor)
{
  last_visitor_ = last_visitor;
}

//---------------------------------------------------------------getLastVisitor-
//
// This returns the last visitor-root during the leaf number actualization
// process.
// @return red Returns the last visitor root.
//
GLint Node::getLastVisitor()
{
  return(last_visitor_);
}

//------------------------------------------------------------------setSelected-
//
// This sets a node to be selected (for highlighting).
// @param is_selected Indicates if a node has been selected.
//
void Node::setSelected(bool is_selected)
{
  is_selected_ = is_selected;
}

//---------------------------------------------------------------addAngleOffset-
//
// This adds some angle value to the angle offset member.
// @param additional_angle_offset The angle offset to add.
//
void Node::addAngleOffset(GLfloat additional_angle_offset)
{
  angle_offset_ += additional_angle_offset;
}

//---------------------------------------------------------------getAngleOffset-
//
// This returns the angle offset of the node.
// @return The angle offset.
//
GLfloat Node::getAngleOffset()
{
  return(angle_offset_);
}

//-----------------------------------------------------------------resetMembers-
//
// This resets the members of the node to default values.
//
void Node::resetMembers()
{
  angular_width_ = 0.0f;
  ring_number_ = 0;
  ring_radius_ = 0;
  polar_phi_ = 0;
  polar_r_ = 0;
  alpha_ = 0;
  red_ = 0;
  green_ = 0;
  blue_ = 0;
  node_radius_ = 0;
  angle_offset_ = 0.0f;
  vector<GLuint>::iterator iter = num_leafs_.begin();
  while (iter != num_leafs_.end())
  {
    (*iter) = 0;
    ++iter;
  }
}

//------------------------------------------------------------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 Node::setSceneRotation(GLfloat x_rotation, GLfloat y_rotation,
                            GLfloat z_rotation)
{
  x_rotation_ = x_rotation;
  y_rotation_ = y_rotation;
  z_rotation_ = z_rotation;
}

// eof

---