QUAD_DBM_2D.h

// File : QUAD_DBM_2D.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 QUAD_DBM_2D_H 
#define QUAD_DBM_2D_H

#define USINGGLUT

#include <vector>
#ifdef USINGGLUT
#include <gl/glut.h>
#endif
#include "DAG.h"
#include "QUAD_POISSON.h"

class QUAD_DBM_2D  
{
public:
        QUAD_DBM_2D(int xRes = 128, int yRes = 128, int iterations = 10);

        virtual ~QUAD_DBM_2D();

  bool addParticle();
  
  bool hitGround(CELL* cell = NULL);
 
#ifdef USINGGLUT

  void draw();

  void drawSegments()  {
    glLineWidth(1.0f);
    glPushMatrix();
    glTranslatef(-0.5f, -0.5f, 0.0f);
    _dag->draw();
    glPopMatrix();
  };
#endif
  
  // file IO

  void writeFields(const char* filename);

  void readFields(const char* filename);

  bool readImage(unsigned char* initial, 
                 unsigned char* attractors,
                 unsigned char* repulsors,
                 unsigned char* terminators,
                 int xRes, int yRes);

  void readDAG(const char* filename)     { _dag->read(filename); };

  void writeDAG(const char* filename)    { _dag->write(filename); };
  
  float*& renderOffscreen(int scale = 1) { return _dag->drawOffscreen(scale); };
  
  int xRes() { return _xRes; };
  int yRes() { return _yRes; };
  int xDagRes() { return _dag->xRes(); };
  int yDagRes() { return _dag->yRes(); };
  int inputWidth() { return _dag->inputWidth(); };
  int inputHeight() { return _dag->inputHeight(); };

private:
  void allocate();
  void deallocate();
  
  // dielectric breakdown model components
  
  // field dimensions
  int _xRes;
  int _yRes;
  int _maxRes;
  float _dx;
  float _dy;
  int _iterations;
  
  // which cell did it hit bottom with?
  int _bottomHit;

  DAG* _dag;

  QUAD_POISSON* _quadPoisson;

  // current candidate list
  vector<CELL*> _candidates;

  // check if any of the neighbors of cell should be added to the
  // candidate list
  void checkForCandidates(CELL* cell);

  // number of particles to add before doing another Poisson solve
  int _skips;

  // Mersenne Twister
  RNG _twister;
};

#endif

---