DAG.h

// File : DAG.h
//
// Copyright 2006
// The University of North Carolina at Chapel Hill
// 
//
// Permission to use, copy, modify, distribute and sell this software and its 
// documentation for any purpose is hereby granted without fee, provided that 
// the above copyright notice appear in all copies and that both that copyright 
// notice and this permission notice appear in supporting documentation. 
// Binaries may be compiled with this software without any royalties or 
// restrictions. 
//
// The University of North Carolina at Chapel Hill makes no representations 
// about the suitability of this software for any purpose. It is provided 
// "as is" without express or implied warranty.
//

#ifndef DAG_H
#define DAG_H

#include <map>
#include <vector>
#include <cmath>
#include <gl/glut.h>

using namespace std;

class DAG  
{
public:
        DAG(int xRes, int yRes);
        virtual ~DAG();

  void buildLeader(int bottomHit);

  bool addSegment(int index, int neighbor);

  void draw() { drawNode(_root); };

  float*& drawOffscreen(int scale = 1);

  void read(const char* filename);
  void write(const char* filename);

  int xRes() { return _xRes; };
  int yRes() { return _yRes; };
 
  int& inputWidth() { return _inputWidth; };
  int& inputHeight() { return _inputHeight; };
  
private:
  int _xRes;
  int _yRes;
  float _dx;
  float _dy;
  
  struct NODE {
    int index;
    vector<NODE*> neighbors;
    NODE* parent;
    bool leader;
    bool secondary;
    int depth;
    NODE* maxDepthNode;
    float intensity;

    NODE(int indexIn) { 
      index = indexIn; 
      parent = NULL;
      leader = false;
      depth = 0;
      maxDepthNode = NULL;
    };
  };
  void deleteNode(NODE* root);

  NODE* _root;

  map<int, NODE*> _hash;

  void buildBranch(NODE* node, int depth);
  void drawNode(NODE* root);
  void findDeepest(NODE* root, NODE*& deepest);

  void readNode(FILE* file);
  void writeNode(NODE* root, FILE* file);

  int _totalNodes;

  int _bottomHit;

  void buildIntensity(NODE* root);
  
  float _secondaryIntensity;
  float _leaderIntensity;

  // offscreen buffer variables
  float* _offscreenBuffer;
  
  int _width;
  
  int _height;
  
  int _scale;
  
  void drawOffscreenNode(NODE* root);

  void drawLine(int begin[], int end[], float intensity);

  int _inputWidth;
  int _inputHeight;
};

#endif

---