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.

2010-10-14    <merks@cwi.nl>

	* mesh.cpp: In response to referees' comments, added new parameter

	"yield_threshold" instead of fixed parameter '4' for yield

	threshold.

	* wallitem.cpp: when clicking a wall, both the wall type was

	cycled and the transporterdialog popped up. Corrected this - for

	wall type cycling, hold the Control button while left

	clicking. TransporterDialog only pops up for left click. Also made

	sure the wall is redrawn after changing the transporter values.

	* cell.cpp (DivideWalls): accomodated for rename of Circumference -> WallCircumference

	* hull.h: added an operator< to sort Points

	* hull.cpp: added an operator< to sort Points

	* cellbase.cpp (ExactCircumference): I added a new function

	ExactCircumference, yielding the circumference of the cell along

	its wall_elements

	* VirtualLeaf.cpp: adjust info_string to accomodate for new name

  clear();

  static int count=0;

  if (resize_stride) {

    if ( !((count)%resize_stride) ) {

      FitLeafToCanvas();

    }

  }

  mesh.LoopCells(DrawCell(),canvas,*this);

  if (ShowNodeNumbersP()) 

    mesh.LoopNodes( bind2nd (mem_fun_ref ( &Node::DrawIndex), &canvas ) ) ;

  if (ShowCellNumbersP()) 

    mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawIndex), &canvas ) ) ;

  if (ShowCellAxesP()) 

    mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawAxis), &canvas ) );

  if (ShowCellStrainP()) 

    mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawStrain), &canvas ) );

  if (ShowWallsP())

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

/*  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();

  }

  Cell::SetMagnification(1);

  Cell::setOffset(0,0);

  FitLeafToCanvas();

  Plot();

}

TIMESTEP {

  static int i=0;

  static int t=0;

  static int ncells;

  if (!batch) {

    UserMessage(QString("Time: %1").arg(mesh.getTimeHours().c_str()),0);

  }

  ncells=mesh.NCells();

  double dh;

  if(DynamicCellsP()) {

    dh = mesh.DisplaceNodes();

    // 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;

    break;

  case QtFatalMsg:

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

    cerr << "Fatal: " << msg << flush;

    abort();

  }

}

Parameter par;

int main(int argc,char **argv) {

  try {

    int c;

    char *leaffile=0;

    char *modelfile=0;

    while (1) {

      //int this_option_optind = optind ? optind : 1;

      int option_index = 0;

      static struct option long_options[] = {

	{"batch", no_argument, NULL, 'b'},

{

  QMatrix m = editor->matrix();

  m.scale( 0.9, 0.9 );

  editor->setMatrix( m );

}

void Main::print()

{

  if ( !printer ) printer = new QPrinter;

  if ( printer->setup(this) ) {

    //    extern Mesh mesh;

    Vector bbll,bbur;

    mesh.BoundingBox(bbll,bbur);

#ifdef QDEBUG

    qDebug() << "bbll = " << bbll << endl;

    qDebug() << "bbur = " << bbur << endl;

#endif

    double cw = (bbur.x - bbll.x);

    double ch = (bbur.y - bbll.y);

    QPainter pp(printer);

    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"

				"Are you sure?"),

			     QMessageBox::Yes | QMessageBox::No, QMessageBox::NoButton ) == QMessageBox::Yes ) {

    cerr << "Restarting simulation" << endl;

    //    extern Mesh mesh;

    mesh.Clear();

    Init();

    Plot();

    editor->FullRedraw();

  } 

  //startSimulation();

}

void Main::FitCanvasToWindow(void)

{

  double scale_factor_x = (double)editor->width()/(double)canvas.width();

  double scale_factor_y = (double)editor->height()/(double)canvas.height();

  double scale_factor = scale_factor_x > scale_factor_y ? scale_factor_x : scale_factor_y;

  QMatrix m = editor->matrix();

#ifdef QDEBUG  

  qDebug() << "editor->width() = " << editor->width() << endl;

#include "cell.h"

#include "node.h"

#include "simplugin.h"

#include <QVector>

#include <QPair>

#include <QDebug>

#include <QTextStream>

using namespace std;

// new queue which rejects duplicate elements

template<class T, class C = deque<T> > class unique_queue : public queue<T,C> {

 public:

 typedef typename C::value_type value_type;

 // reimplements push: reject element if it exists already

 void push(const value_type &x) {

   if (find (queue<T,C>::c.begin(),queue<T,C>::c.end(),x)==queue<T,C>::c.end()) {

     queue<T,C>::c.push_back(x);

   }

 }

 void clear(void) {

   queue<T,C>::c.clear();

 }

};

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;

      qDebug() << "size is " << cells.size() << endl;

#endif

      abort();

    }

  }

  inline Node &getNode(int i) {

    return *nodes[i];    

  }

  //double Diffusion(void);

  inline int size(void) {

    return cells.size();

  }

  inline int nnodes(void) {

    return nodes.size();

  }

  template<class Op> void LoopCells(Op f) {

    for (vector <Cell *>::iterator i=cells.begin();

	 i!=cells.end();

	 i++) {

      f(**i);

    }

  void CleanUpCellNodeLists(void);

  void CleanUpWalls(void);

  void CutAwayBelowLine( Vector startpoint, Vector endpoint );

  void CutAwaySAM(void);

  void RepairBoundaryPolygon(void);

  void Rotate(double angle, Vector center);

  void PrintWallList( void );

  void TestIllegalWalls(void);

  Vector FirstConcMoment(int chem);

  inline Vector Centroid(void) {

    return boundary_polygon->Centroid();

  }

  inline Vector Offset(void) {

    return boundary_polygon->Offset();

  }

  inline double Factor(void) {

    return boundary_polygon->Factor();

  }

  void DeleteLooseWalls(void);

  void FitLeafToCanvas(double width, double height);

  void AddNodeSet(NodeSet *node_set) {

    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;

    return n;

  }

  inline Cell *AddCell(Cell *c) {

    cells.push_back(c);

    shuffled_cells.push_back(c);

    //cerr << "Shuffled cell indices:  ";

    /*copy(shuffled_cells.begin(),shuffled_cells.end(),ostream_iterator<int>(cerr," "));

      cerr << endl;*/

    c->m=this;

    return c;

  }

  void CircumCircle(double x1,double y1,double x2,double y2,double x3,double y3,

		    double *xc,double *yc,double *r);

};

#endif

/* finis */