$(MAKE) -f Makefile.libplugin

Makefile.libplugin: libplugin.pro

	$(QMAKE) -o $@ $< 

plugins:

	$(MAKE) -C build_models -f Makefile

tutorials:

	$(MAKE) -C build_models -f Makefile

	$(MAKE) -C TutorialCode -f Makefile

clean:

	$(MAKE) -f Makefile.libplugin clean

	$(MAKE) -f Makefile.VirtualLeaf clean

	$(MAKE) -C build_models -f Makefile clean

	$(MAKE) -C TutorialCode -f Makefile clean

ifeq ($(MAKE),make)

	touch VirtualLeaf.pro

	touch libplugin.pro

else

	copy /b VirtualLeaf.pro +,,

	copy /b libplugin.pro +,,

endif

      fname << count << ".xml";

      // Write XML file every ten plot steps

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

    }

  }

}

INIT {

  //mesh.SetSimPlugin(plugin);

  if (leaffile) { 

  } else {

    mesh.StandardInit();

  }

  Cell::SetMagnification(1);

  Cell::setOffset(0,0);

  FitLeafToCanvas();

  Plot();

}

    } else {

      main_window=new MainBase(canvas, mesh);

    }

    canvas.setSceneRect(QRectF());

    if (!batch) {

      QObject::connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()) );

    }

    //    main_window->Init(leaffile);

    // Install model or read catalogue of models

    if (useGUI)

      model_catalogue.PopulateModelMenu();

    model_catalogue.InstallFirstModel();

    /*    Cell::SetMagnification(1);

    Cell::setOffset(0,0);

    main_window->FitLeafToCanvas();

title = Parameter values for The Virtual Leaf / title

label = <b>Visualization</b> / label

arrowcolor = white / string

arrowsize = 100 / double

textcolor = red / string

cellnumsize = 1 / int

nodenumsize = 1 / int

node_mag = 1.0 / double 

outlinewidth = 1.0 / double

cell_outline_color = forestgreen / string

resize_stride = 0 / int

label = / label

label = <b>Cell mechanics</b> / label

T = 1.0 / double

lambda_length = 100. / double

yielding_threshold = 4. / double

lambda_celllength = 0. / double

target_length = 60. / double 

cell_expansion_rate = 1. / double

cell_div_expansion_rate = 0. / double

auxin_dependent_growth = true / bool

ode_accuracy = 1e-4 / double

mc_stepsize = 0.4 / double

mc_cell_stepsize = 0.2 / double

#label = / label

#label = <b>miscellaneous</b> / label

van3prod = 0.002 / double

van3autokat = 0.1 / double

van3sat = 10 / double

k2van3 = 0.3 / double

#glvprod = 0.0 / double

#glvbreakdown = 0. / double

label = / label

label = <b>Integration parameters</b> / label

dt = 0.1 / double 

rd_dt = 1.0 / double

movie = false / bool

nit = 100000 / int

maxt = 1000. / double

rseed = -1 / int

#label = / label

#label = <b>Parameters for new chemical</b> / label

#glvproduction = 0. / double

#glvdecay = 0. / double

#glvdiffthreshold = 0. / double

label = / label

label = <b>Meinhardt leaf venation model</b> / label

constituous_expansion_limit = 16 / int

vessel_inh_level = 1 / double

vessel_expansion_rate = 0.25 / double

d = 0. / double

i3 = 0 / int

i4 = 0 / int

i5 = 0 / int

s1 =  / string

s2 =  / string

s3 =  / string

b1 = false / bool

b2 = false / bool

b3 = false / bool

b4 = false / bool

dir1 = . / directory

dir2 = . / directory

  // emit this signal

  QObject::connect(   this, SIGNAL( ParsChanged() ), pardial, SLOT( Reset() ) );

}

void Main::savePars()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  fd->setMode( Q3FileDialog::AnyFile );

  fd->setFilter( "Parameter files (*.par)");

  QString fileName;

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    ofstream parfile((const char *)fileName);

    par.Write(parfile);

  }

  startSimulation();

}

void Main::readPars()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  fd->setMode( Q3FileDialog::ExistingFile );

  fd->setFilter( "Parameter files (*.par)");

  QString fileName;

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    par.Read((const char *)fileName);

  }

  emit ParsChanged();

}

void Main::saveStateXML()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  fd->setMode( Q3FileDialog::AnyFile );

  fd->setFilter( "LeafML files (*.xml)");

  QString fileName;

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    if ( QFile::exists( fileName ) &&

	 QMessageBox::question(

			       this,

			       tr("Overwrite File? -- Leaf Growth"),

			       tr("A file called %1 already exists."

				  " Do you want to overwrite it?")

			       .arg( fileName ),

			       tr("&Yes"), tr("&No"),

    }

  }

}

void Main::snapshot()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "Save snapshot", TRUE );

  fd->setMode( Q3FileDialog::AnyFile );

  fd->setFilter( "Image files (*.pdf *.png *.jpg *.tif *.bpm)");

  QString fileName;

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    // extract extension from filename

    QFileInfo fi(fileName);

    QString extension = fi.suffix();

    if (extension.isEmpty()) {

    QString currentFile_nopath = currentFile.section( '/', -1 );

    QString currentFile_path = currentFile.section( '/', 0, -2 );

    next_file = xml_files.front();

    next_file = currentFile_path+"/"+next_file;

    readStateXML((const char*)next_file);

  }

}

void Main::readStateXML()

{

  //  extern Mesh mesh;

  stopSimulation();

#ifdef QDEBUG

  qDebug() << "Trying to open an OptionFileDialog" << endl;

#endif

  OptionFileDialog *fd = new OptionFileDialog( this, "read dialog", TRUE );

  fd->setMode( OptionFileDialog::ExistingFile );

  fd->setFilter( "LeafML files (*.xml)");

  if (working_dir) {

    fd->setDir(*working_dir);

  }

  QString fileName;

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    if (working_dir) {

      delete working_dir;

    }

    working_dir = fd->dir();

    if (readStateXML((const char *)fileName,fd->readGeometryP(), fd->readParametersP()) )

      return readStateXML(); // user can try again

  dynamicscellsp = options->isItemChecked(dyn_cells_id);

  showwallsp = view->isItemChecked( cell_walls_id);

  //showapoplastsp = view->isItemChecked( apoplasts_id);

  hidecellsp = view->isItemChecked( hide_cells_id);

  xmlNode *settings = MainBase::XMLSettingsTree();

  QTransform viewport(editor->transform());

  xmlAddChild(settings, XMLViewportTree(viewport));

  return settings;

}

void Main::exportCellData(QString fileName) {

#ifdef QDEBUG  

  qDebug() << "exportCellData fileName: " << fileName << endl;

#endif

  QFile file(fileName);

  if ( file.open( IO_WriteOnly ) ) {

    QTextStream stream( &file );

    mesh.CSVExportCellData(stream);

    mesh.CSVExportMeshData(stream);

    file.close();

  }

}

void Main::exportCellData() {

  QString fileName;

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  stopSimulation();

  fd->setMode( Q3FileDialog::AnyFile );

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    // extract extension from filename

    QFileInfo fi(fileName);

    QString extension = fi.suffix();

    if (extension.isEmpty()) {

      extension = "csv";

      fileName += ".";

 *

 */

#ifndef _CANVAS_H_

#define _CANVAS_H_

#include <q3popupmenu.h>

#include <q3mainwindow.h>

#include <q3intdict.h>

#include <QGraphicsScene>

#include <QGraphicsView>

#include <QList>

#include <string>

#include <sstream>

//Added by qt3to4:

#include <QMouseEvent>

#include <vector>

#include "simitembase.h"

#include "mainbase.h"

#include "cellitem.h"

#include "infobar.h"

  void toggleCellAxes(void);

  void toggleCellStrain(void);

  void toggleShowWalls(void);

  void toggleShowApoplasts(void);

  void toggleDynCells(void);

  void toggleMovieFrames(void);

  void toggleLeafBoundary(void);

  void toggleHideCells(void);

  void print();

  void startSimulation(void);

  void stopSimulation(void);

  void RefreshInfoBar(void);

  void EnterRotationMode(void)

  {

    UserMessage("Rotation mode. Click mouse to exit.");

    if (editor) {

      editor->rot_angle = 0. ; 

      // Exit rotation mode if mouse is clicked

      connect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));

      editor->setMouseTracking(true);

  }

  virtual void UserMessage(QString message, int timeout=0);

  void Refresh(void) { Plot(); }

  void PauseIfRunning(void);

  void ContIfRunning(void);

  virtual void XMLReadSettings(xmlNode *settings);

  private slots:

  void aboutQt();

  void newView();

  void EditParameters();

  void readStateXML();

  void readNextStateXML();

  void readPrevStateXML();

  void readFirstStateXML();

  void readLastStateXML();

  void exportCellData();

  void exportCellData(QString);

  void saveStateXML();

  void snapshot();

  void savePars();

  void readPars();

  void clear();

  void init();

       i++) {

    Vector centroid = (*i)->Centroid();

    csv_stream << (*i)->Index() << ", "

	       << centroid.x << ", "

	       << centroid.y << ", " 

	       <<  (*i)->Area() << ", "

	       <<(*i)->Length();

    for (int c=0;c<Cell::NChem(); c++) {

      csv_stream << ", " << (*i)->Chemical(c);

    }

    csv_stream << endl;

  }

}

void Mesh::CSVExportMeshData(QTextStream &csv_stream) { 

  csv_stream << "\"Morph area\",\"Number of cells\",\"Number of nodes\",\"Compactness\",\"Hull area\",\"Morph circumference\",\"Hull circumference\"" << endl;

  double res_compactness, res_area, res_cell_area, hull_circumference;

  Compactness(&res_compactness, &res_area, &res_cell_area, &hull_circumference);

  double morph_circumference = boundary_polygon->ExactCircumference();

  csv_stream << Area() << ", " << NCells() << ", " << NNodes() << ", " << res_compactness << ", " << res_area << ", " << morph_circumference << ", " << hull_circumference << endl;

  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;

 *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

 *

 *  Copyright 2010 Roeland Merks.

 *

 */

#include <string>

#include "modelcatalogue.h"

#include <QVariant>

static const std::string _module_id("$Id$");

  mesh = _mesh;

  mainwin = _mainwin;

  if (model) {

    cerr << "Loading model: " << model << endl;

    LoadPlugin(model);

  } else {

    cerr << "Loading all models." << endl;

    LoadPlugins();

  }

}

void ModelCatalogue::LoadPlugins() {

      //MyWarning::warning("Successfully loaded model %s",fileName.toStdString().c_str());

    } else {

      MyWarning::warning("Could not load plugin %s",fileName.toStdString().c_str());

    }

  }

}

void ModelCatalogue::InstallFirstModel() {

  InstallModel(models[0]);

}

void ModelCatalogue::PopulateModelMenu() {

  foreach (SimPluginInterface *model, models) {

    QVariant data;

    data.setValue(model);

    modelaction->setData(data);

  }

}	

void ModelCatalogue::InstallModel(QAction *modelaction) {

  QVariant data = modelaction->data();

  SimPluginInterface *model = data.value<SimPluginInterface *>();

  cerr << "You chose model " << model->ModelID().toStdString() << "!\n";

  mesh->Clean();

  InstallModel(model);

}

void ModelCatalogue::InstallModel(SimPluginInterface *plugin) {

  // make sure both main and plugin use the same static datamembers (ncells, nchems...)

  mesh->Clean();

  plugin->SetCellsStaticDatamembers(CellBase::GetStaticDataMemberPointer());

  mesh->SetSimPlugin(plugin);

  Cell::SetNChem(plugin->NChem());

  plugin->SetParameters(&par);

  if (mainwin) {

    if (plugin->DefaultLeafML().isEmpty()) {

      mainwin->Init(0);

    } else {

      // locate LeafML file

      QDir pluginDir(QApplication::applicationDirPath()); 

      QStringList plugin_filters; // filter for plugins, i.e "*.dll", "*.dylib"

#if defined(Q_OS_WIN) 

      if (pluginDir.dirName().toLower() =="debug" 

	  ||pluginDir.dirName().toLower() =="release") 

#include <QPluginLoader>

#include <Q3PopupMenu>

#include <QAction>

#include <QDir>

#include <QApplication>

#include <QObject>

#include <QAction>

#include <QMenu>

class ModelCatalogue : public QObject {

  Q_OBJECT

    public:

  void LoadPlugins(); 

  void LoadPlugin(const char *model);

  void InstallFirstModel();

  void PopulateModelMenu();	

  public slots:

  void InstallModel(SimPluginInterface *model);	

  void InstallModel(QAction *modelaction);

 private:

  QVector<SimPluginInterface *> models;

  Mesh *mesh;

};

#endif

/* finis */

static const std::string _module_id("$Id$");

Parameter::Parameter() {

  arrowcolor = strdup("white");

  arrowsize = 100;

  textcolor = strdup("red");

  cellnumsize = 1;

  nodenumsize = 1;

  node_mag = 1.0;

  outlinewidth = 1.0;

  cell_outline_color = strdup("forestgreen");

  resize_stride = 0;

  T = 1.0;

  lambda_length = 100.;

  yielding_threshold = 4.;

  lambda_celllength = 0.;

  target_length = 60.;

  cell_expansion_rate = 1.;

  cell_div_expansion_rate = 0.;

  auxin_dependent_growth = true;

  ode_accuracy = 1e-4;

  mc_stepsize = 0.4;

  mc_cell_stepsize = 0.2;

  energy_threshold = 1000.;

  kaux1 = 1;

  kap = 1;

  leaf_tip_source = 0.001;

  sam_efflux = 0.0001;

  sam_auxin = 10.;

  sam_auxin_breakdown = 0;

  van3prod = 0.002;

  van3autokat = 0.1;

  van3sat = 10;

  k2van3 = 0.3;

  dt = 0.1;

  rd_dt = 1.0;

  movie = false;

  nit = 100000;

  maxt = 1000.;

  rseed = -1;

  constituous_expansion_limit = 16;

  vessel_inh_level = 1;

  vessel_expansion_rate = 0.25;

  d = 0.;

  e = 0.;

  f = 0.;

  c = 0.;

  mu = 0.;

  nu = 0.;

  rho0 = 0.;

  rho1 = 0.;

  i3 = 0;

  i4 = 0;

  i5 = 0;

  s1 = strdup("");

  s2 = strdup("");

  s3 = strdup("");

  b1 = false;

  b2 = false;

  b3 = false;

  b4 = false;

  dir1 = strdup(".");

  dir2 = strdup(".");

}

Parameter::~Parameter() {

// destruct parameter object

// free string parameter

CleanUp();

}

void Parameter::CleanUp(void) {

  if (arrowcolor) 

     free(arrowcolor);

  if (textcolor) 

     free(textcolor);

  if (cell_outline_color) 

     free(cell_outline_color);

  if (D) 

     free(D);

  if (initval) 

     free(initval);

  if (k) 

     free(k);