2010-10-15    <guravage@caterpie.sen.cwi.nl>

	* mesh.h (Mesh): Added iterations. incrementIterations() and

	getIterations().

	* VirtualLeaf.cpp (Plot): Replaced local frame counter with

	mesh.incrementIterations().

	* canvas.cpp (TimeStepWrap): Replaced local counter with

	mesh.incrementIterations().

2010-10-14    <guravage@caterpie.sen.cwi.nl>

	* VirtualLeaf.pro: Turned debug off to make all profiles must be

	consistant.

	* VirtualLeaf-install.nsi: Tweaked paths to coincide with UNIX

	distribution, i.e. VirtualLeaf.exe, its libraries, models, and the

	uninstaller all go in the bin directory. And leaves directory

	placed under data directory.

	* canvas.cpp (exportCellData): Added a check to inquire before

	overwritting an existing file.

/*  if (ShowApoplastsP()) 

    mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::DrawApoplast ), &canvas ) );

*/

  if (ShowMeshP()) 

    mesh.DrawNodes(&canvas);

  if (ShowBoundaryOnlyP()) 

    mesh.DrawBoundary(&canvas);

  if ( ( batch || MovieFramesP() )) {

     static int frame = 0;

    // frame numbers are sequential for the most frequently written file type.

    // for the less frequently written file type they match the other type

    if (!(count%par.storage_stride) )  {

      stringstream fname;

      fname << par.datadir << "/leaf.";

      fname.fill('0');

      fname.width(6);

      fname << frame << ".jpg";

      if (par.storage_stride <= par.xml_storage_stride) {

      }

      // Write high-res JPG snapshot every plot step

      Save(fname.str().c_str(), "JPEG",1024,768);

    }

    if (!(count%par.xml_storage_stride)) {

      stringstream fname;

      fname << par.datadir << "/leaf.";

      fname.fill('0');

      fname.width(6);

      fname << frame << ".xml";

      if (par.xml_storage_stride < par.storage_stride) {

      }

      // Write XML file every ten plot steps

      mesh.XMLSave(fname.str().c_str(), XMLSettingsTree());

    }

  }

 count++;

}

INIT {

  //mesh.SetSimPlugin(plugin);

  if (leaffile) { 

    xmlNode *settings;

    mesh.XMLRead(leaffile, &settings);

    main_window->XMLReadSettings(settings);

    xmlFree(settings);

    main_window->UserMessage(QString("Ready. Time is %1").arg(mesh.getTimeHours().c_str()));

  } else {

    mesh.StandardInit();

  }

    // Only allow for node insertion, cell division and cell growth

    // if the system has equillibrized

    // i.e. cell wall tension equillibrization is much faster

    // than biological processes, including division, cell wall yielding

    // and cell expansion

    mesh.InsertNodes(); // (this amounts to cell wall yielding)

    if ( (-dh) < par.energy_threshold) {

      mesh.IncreaseCellCapacityIfNecessary();

      mesh.DoCellHouseKeeping();

      //mesh.LoopCurrentCells(mem_fun(&plugin->CellHouseKeeping)); // this includes cell division

      // Reaction diffusion	

      mesh.ReactDiffuse(par.rd_dt);

      t++;

      Plot(par.resize_stride);

    }

  } else {

    mesh.ReactDiffuse(par.rd_dt);

    Plot(par.resize_stride);

  }

  i++;

  return mesh.getTime();

}

/* Called if a cell is clicked */

void Cell::OnClick(QMouseEvent *e){}

/* Custom message handler - Default appends a newline character to the end of each line. */ 

void vlMessageOutput(QtMsgType type, const char *msg)

{

  switch (type) {

  case QtDebugMsg:

    //fprintf(stderr, "Debug: %s\n", msg);

    cerr << msg << flush;

    break;

  case QtWarningMsg:

    //fprintf(stderr, "Warning: %s\n", msg);

    cerr << "Warning: " << msg << flush;

    break;

  case QtCriticalMsg:

    fprintf(stderr, "Critical: %s\n", msg);

    cerr << "Critical: " << msg << flush;

    QRect vp=pp.viewport();

#ifdef QDEBUG

    qDebug() << "Paper width = " << vp.width() << " x " << vp.height() << endl;

#endif

    // Note that Cell is also translated...

    pp.translate(-bbur.x,-bbur.y);

    if (cw>ch) {

      pp.scale(vp.width()/(2*cw*Cell::Magnification()), vp.width()/(2*cw*Cell::Magnification()));

    } else {

      pp.scale(vp.height()/(2*ch*Cell::Magnification()), vp.height()/(2*ch*Cell::Magnification()));

    }

    canvas.render(&pp, QRectF(), QRectF(0.,0.,canvas.width(),canvas.height()));

  }

}

void Main::TimeStepWrap(void)

{

  static int t;

  stringstream fname;

  TimeStep();

  if ((par.export_interval > 0) && !(t%par.export_interval)){

    fname << par.datadir << "/" << par.export_fn_prefix;

    fname.fill('0');

    fname.width(6);

    fname << t << ".csv";

    this->exportCellData(QString(fname.str().c_str()));

  }

  // check number of timesteps

  if (t == par.nit) {

    emit SimulationDone();

  }

}

void Main::RestartSim(void)

{

  stopSimulation();

  if ( QMessageBox::question(

			     this,

			     tr("Restart simulation?"),

			     tr("Restart simulation.\n"

template<class P> P& deref_ptr ( P *obj) { return *obj; }

class Mesh {

  friend class Cell;

  friend class Node;

  friend class FigureEditor;

 public: 

  Mesh(void) {

    // Make sure the reserved value is large enough if a cell is added

    // in "Divide" when the capacity is insufficient, "cells" might be

    // relocated including the current Cell (i.e. the value of *this)

    // calling "Mesh::IncreaseCapacityIfNecessary" (from another

    // object than Cell, e.g. Mesh) before entering Divide will solve

    // this issue (solved now).

    cells.reserve(2);

    nodes.reserve(500);

    time = 0.;

    plugin = 0;

    boundary_polygon=0;

  };

  ~Mesh(void) {

    if (boundary_polygon) {

      delete boundary_polygon;

      boundary_polygon=0;

    }

  };

  void Clean(void);

  Cell &EllipticCell(double xc, double yc, double ra, double rb, int nnodes=10, double rotation=0);

  Cell &CircularCell(double xc, double yc, double r, int nnodes=10) {

    return EllipticCell(xc, yc, r, r, nnodes, 0);

  }

  Cell &LeafPrimordium(int n, double pet_length);

  Cell &LeafPrimordium2(int n);

  Cell *RectangularCell(const Vector ll, const Vector ur, double rotation = 0);

  void CellFiles(const Vector ll, const Vector ur);

  inline Cell &getCell(int i) {

    if ((unsigned)i<cells.size())

      return *cells[i];

    else {

#ifdef QDEBUG

      qDebug() << i << endl;

    node_sets.push_back(node_set);

  }

  void CleanChemicals(const vector<double> &clean_chem);

  void CleanTransporters(const vector<double> &clean_transporters);

  void RandomizeChemicals(const vector<double> &max_chem, const vector<double> &max_transporters);

  inline double getTime(void) const { return time; }

  string getTimeHours(void) const; 

  inline void setTime(double t) { time = t; }

  double CalcProtCellsWalls(int ch) const;  

  void SettoInitVals(void);

  QVector<qreal> VertexAngles(void);

  QVector< QPair<qreal,int> > VertexAnglesValues(void);

  void SetSimPlugin(SimPluginInterface *new_plugin) {

    plugin=new_plugin;

  }

  QString ModelID(void) { return plugin?plugin->ModelID():QString("undefined"); }

  void StandardInit(void);	

  double Compactness(double *res_compactness=0, double *res_area=0, double *res_cell_area=0, double *hull_circumference=0);

  void CSVExportCellData(QTextStream &csv_stream) const;

  void CSVExportMeshData(QTextStream &csv_stream);

  Node* findNextBoundaryNode(Node*);

 private:

  // Data members

  vector<Cell *> cells;

  vector<Node *> nodes;

  list<Wall *> walls; // we need to erase elements from this container frequently, hence a list.

 public:

  vector<NodeSet *> node_sets;

 private:

  vector<Node *> shuffled_nodes;

  vector<Cell *> shuffled_cells;

  unique_queue<Edge> node_insertion_queue;

  BoundaryPolygon *boundary_polygon;

  double time;

  SimPluginInterface *plugin;

  // Private member functions

  void AddNodeToCell(Cell *c, Node *n, Node *nb1 , Node *nb2);

  void AddNodeToCellAtIndex(Cell *c, Node *n, Node *nb1 , Node *nb2, list<Node *>::iterator ins_pos);

  void InsertNode(Edge &e);

  inline Node *AddNode(Node *n) {

    nodes.push_back(n);

    shuffled_nodes.push_back(n);

    n->m=this;