omgmodel.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Tim Sutton   *
 *   tim@linfiniti.com   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "omgmodel.h"
#include "omgui.h"
#include "omggraph.h"
#include "omggdal.h"

#include <QString>
#include <QDir>
#include <QFile>
#include <QTextStream>
#include <QFileInfo>
#include <QDomDocument>
#include <QDomElement>
#include <QSettings>
#include <QImage>

#include <qgsrasterlayer.h>
#include <qgsrasterbandstats.h>


OmgModel::OmgModel() : QObject(), OmgSerialisable(), OmgGuid(),
  mCoordinateSystem(""),
  mCoordinateSystemName(QObject::tr("None Selected")),
  mSpeciesFile(""),
  mTaxonName(""),
  //OmgLayer mOutputFormatLayer,
  //OmgLayerSet mProjectionLayerSet,
  //OmgLayerSet mCreationLayerSet,
  //OmgAlgorithm mAlgorithm,
  mCompletedFlag(false),
  mErrorFlag(false),
  //OmgLocalities mLocalities,
  //QDateTime mStartDateTimeStamp,
  //QDateTime mEndDateTimeStamp,
  mThumbnailFileName(""),
  mPreviewFileName(""),
  mLegendFileName(""),
  mRawImageFileName(""),
  mShapefileName(""),
  mCsvFileName(""),
  mColouredImageFileName(""),
  mWorkDir(""),
  mModelDefinition(""),
  mNormalizationDefinition(""),
  mRocScore(0.0),
  mAccuracy(0.0),
  mOmission(0.0),
  mCommission(-1), //initialise to -1 to show its invalid until set
  mPercentCellsPresent(0.0),
  mTotalCells(0.0),
  mModelLog(""),
  mModelRasterFormat("GreyTiff"),
  mLocalitiesFilterType(NO_FILTER)
{

}

OmgModel::~OmgModel()
{

}

bool OmgModel::isValid() const
{
  return true;
}

void OmgModel::reset()
{
  mErrorFlag=false;
  mCompletedFlag=false;
}

QString OmgModel::toString() const
{
  QString myModel("Model Description:\n---------------------\n");
  myModel += "Coordinate System:\n";
  myModel += mCoordinateSystem + "\n";
  myModel += "Coordinate System Name:\n";
  myModel += mCoordinateSystemName + "\n";
  myModel += "Species File:\n";
  myModel += mSpeciesFile + "\n";
  myModel += "Taxon Name:\n";
  myModel += mTaxonName + "\n";
  myModel += "Model creationing Mask:\n";
  myModel += mCreationLayerSet.maskName() + "\n";
  myModel += "Model Projecting Mask\n";
  myModel += mProjectionLayerSet.maskName() + "\n";
  myModel += "Output Format Layer:\n";
  myModel += mOutputFormatLayer.name() + "\n";
  myModel += "Layers used to create the model:\n";
  myModel += mCreationLayerSet.toString() + "\n";
  myModel += "Layers used to project the model:\n";
  myModel += mProjectionLayerSet.toString() + "\n";
  myModel += "Number of localities used to create the model:";
  myModel += QString::number(mLocalities.count()) + "\n";
  myModel += "Output preview image file:\n";
  myModel += mPreviewFileName+"\n";
  myModel += "Output legend file:\n";
  myModel += mLegendFileName+"\n";
  myModel += "Algorithm details:\n";
  //TODO implement toString in alg class
  myModel += mAlgorithm.toString() + "\n";
  return myModel;
}

bool OmgModel::fromXml(const QString theXml) 
{
  QDomDocument myDocument("model");
  myDocument.setContent(theXml);
  QDomElement myRootElement = myDocument.firstChildElement("Model");
  if (myRootElement.isNull())
  {
    //TODO - just make this a warning
    //qDebug("top element could not be found!");
    return false;
  }
  mCompletedFlag = (myRootElement.attribute("Completed")=="true") ? true : false;
  mErrorFlag = (myRootElement.attribute("Error")=="true") ? true : false;
  //@TODO make guid a attribute of model rather
  QString myGuid= myRootElement.attribute("Guid");
  setGuid( myGuid );
  mTaxonName = myRootElement.firstChildElement("TaxonName").text();
  mSpeciesFile = myRootElement.firstChildElement("SpeciesFile").text();
  mWorkDir = myRootElement.firstChildElement("WorkingDirectory").text();
  //@TODO check if simply calling text gets back the mode def properly!
  mModelDefinition = myRootElement.firstChildElement("Definition").text();
  mNormalizationDefinition = myRootElement.firstChildElement("Normalization").text();
  mModelLog = myRootElement.firstChildElement("Log").text();
  QDomElement myStatsElement = myRootElement.firstChildElement("Stats");
  mRocScore = myStatsElement.attribute("RocScore").toDouble();
  mAccuracy = myStatsElement.attribute("Accuracy").toDouble();
  mOmission = myStatsElement.attribute("Omission").toDouble();
  mCommission = myStatsElement.attribute("Commission").toDouble();
  mPercentCellsPresent = myStatsElement.attribute("PercentCellsPresent").toDouble();
  mTotalCells = myStatsElement.attribute("TotalCells").toDouble();
  //loop through the roc points
  mRocPoints.clear();
  QDomElement myRocStatsElement = myStatsElement.firstChildElement("RocStats");
  QDomElement myRocPointElement = myRocStatsElement.firstChildElement("RocPoint");
  while(!myRocPointElement.isNull()) 
  {
    if (myRocPointElement.tagName()!="RocPoint")
    {
      myRocPointElement = myRocPointElement.nextSiblingElement();
      continue;
    }
    QPair<double,double> myPair;
    myPair.first  = myRocPointElement.attribute("x").toDouble();
    myPair.second = myRocPointElement.attribute("y").toDouble();
    addRocPoint(myPair);
    myRocPointElement = myRocPointElement.nextSiblingElement();
  }
  //get teh coord system info
  QDomElement myCoordinateSystemElement=myRootElement.firstChildElement("CoordinateSystem");
  //get teh localities filter if any
  QDomElement myOptionsElement=myRootElement.firstChildElement("Options");
  QDomElement myFilterElement=myOptionsElement.firstChildElement("OccurrencesFilter");
  QDomElement myFilterTypeElement=myOptionsElement.firstChildElement("SpatiallyUnigue");
  if (!myFilterTypeElement.isNull())
  {
    mLocalitiesFilterType=SPATIALLY_UNIQUE;
  }
  else
  {
    myFilterTypeElement=myOptionsElement.firstChildElement("EnvironmentallyUnigue");
    if (!myFilterTypeElement.isNull())
    {
      mLocalitiesFilterType=ENVIRONMENTALLY_UNIQUE;
    }
    else
    {
      mLocalitiesFilterType=NO_FILTER;
    }
  }
  //get teh coordinate system
  mCoordinateSystemName = myCoordinateSystemElement.firstChildElement("Name").text();
  mCoordinateSystem = myCoordinateSystemElement.firstChildElement("WKT").text();
  //get the timing data
  QDomElement myTimingElement = myRootElement.firstChildElement("Timing");
  mStartDateTimeStamp.setTime_t(myTimingElement.attribute("Start").toUInt());
  mEndDateTimeStamp.setTime_t(myTimingElement.attribute("End").toUInt());
  //get teh output images
  QDomElement myOutputImagesElement=myRootElement.firstChildElement("OutputImages");
  QDomElement myThumbnailElement=myOutputImagesElement.firstChildElement("ThumbnailImage");
  QDomElement myPreviewElement=myOutputImagesElement.firstChildElement("PreviewImage");
  QDomElement myLegendElement=myOutputImagesElement.firstChildElement("LegendImage");
  QDomElement myRawImageElement=myOutputImagesElement.firstChildElement("RawImage");
  QDomElement myModelRasterFormatElement=myOutputImagesElement.firstChildElement("ModelRasterFormat");
  QDomElement myColouredImageElement=myOutputImagesElement.firstChildElement("ColouredImage");
  setThumbnailFileName( myThumbnailElement.text() );
  setPreviewFileName( myPreviewElement.text() );
  setLegendFileName( myLegendElement.text() );
  setRawImageFileName( myRawImageElement.text() );
  setColouredImageFileName( myColouredImageElement.text() );
  if (!myModelRasterFormatElement.isNull())
  {
    setModelRasterFormat(myModelRasterFormatElement.text());
  }

  //
  //restore the algorithm section
  //
  QDomElement myAlgorithmElement= myRootElement.firstChildElement("Algorithm");
  if (!myAlgorithmElement.isNull())
  {
    OmgAlgorithm myAlgorithm;
    //get a textual xml representation of the param tag
    QDomDocument myAlgorithmDoc("algorithm");
    //note we need to do a deep copy here because the
    //element is shared otherwise and when we
    //reparent it the loop stops after the first node
    //as no more siblings are found!
    QDomElement myCopy = myAlgorithmElement.cloneNode().toElement();
    myAlgorithmDoc.appendChild(myCopy);
    QString myXml = myAlgorithmDoc.toString();
    //now hand over the xml snippet to the model class to be deserialised
    if (myAlgorithm.fromXml(myXml))
    {
      setAlgorithm(myAlgorithm);
    }
    else
    {
      //return false;
    }
  }
  //
  // restore the localities
  mShapefileName = myRootElement.firstChildElement("Localities").firstChildElement("ShapefileName").text();
  mCsvFileName= myRootElement.firstChildElement("Localities").firstChildElement("CsvFileName").text();

  // @NOTE this code is a near duplication of code in omgexperiment::parsemodel()
  // and the two implementations should be refactored into one function

  mLocalities.clear();
  QDomElement myLocalityElement = myRootElement.firstChildElement("Localities").firstChildElement();
  while(!myLocalityElement.isNull()) 
  {
    if (myLocalityElement.tagName()!="Point")
    {
      myLocalityElement = myLocalityElement.nextSiblingElement();
      continue;
    }
    //qDebug("Parser found a point");
    OmgLocality myLocality;
    QString myId=myLocalityElement.attribute("Id");
    myLocality.setId(myId);
    QString myX=myLocalityElement.attribute("X");
    myLocality.setLongitude(myX.toDouble());
    QString myY=myLocalityElement.attribute("Y");
    myLocality.setLatitude(myY.toDouble());
    // this should be ignored by the omlib
    // but is used for de/serialising 
    // localities in the desktop so dont remove it
    QString myAbundance=myLocalityElement.attribute("Abundance");
    myLocality.setAbundance(myAbundance.toDouble());
    QString mySample=myLocalityElement.attribute("Sample");
    //qDebug("Sample for point: " + mySample.toLocal8Bit());
    QStringList myList=mySample.split(" ");
    QStringListIterator myIterator(myList);
    OmgSampleVector mySamples;
    while (myIterator.hasNext())
    {
      double myDouble=myIterator.next().toDouble();
      mySamples.push_back(myDouble);
    }
    myLocality.setSamples(mySamples);
    mLocalities.push_back(myLocality);
    myLocalityElement = myLocalityElement.nextSiblingElement();
  }
  //
  // Restore the output layer format
  //
  QDomElement myOutputFormatElement = myRootElement.firstChildElement("OutputFormatLayer").firstChildElement("Map");
  OmgLayer myLayer;
  myLayer.setName(myOutputFormatElement.attribute("Id"));
  QString myCategoricalString = myOutputFormatElement.attribute("IsCategorical" );
  myLayer.setCategorical((myCategoricalString=="0")? false : true);
  mOutputFormatLayer=myLayer;
  //
  // Restore the creation layerset
  //
  QDomElement myLayerSetElement = myRootElement.firstChildElement("CreationLayerSet").firstChildElement();
  QDomDocument myLayerSetDoc("layerset");
  //note we need to do a deep copy here because the
  //element is shared otherwise and when we
  //reparent it the loop stops after the first node
  //as no more siblings are found!
  QDomElement myCopy1 = myLayerSetElement.cloneNode().toElement();
  myLayerSetDoc.appendChild(myCopy1);
  QString myXml1 = myLayerSetDoc.toString();
  OmgLayerSet myLayerSet;
  //now hand over the xml snippet to the layerset class to be deserialised
  if (myLayerSet.fromXml(myXml1))
  {
    mCreationLayerSet = myLayerSet;
  }
  else
  {
    //return false;
  }
  //
  // Restore the projections layerset
  //
  QDomElement myLayerSetElement2 = myRootElement.firstChildElement("ProjectionLayerSet").firstChildElement();
  QDomDocument myLayerSetDoc2("layerset");
  //note we need to do a deep copy here because the
  //element is shared otherwise and when we
  //reparent it the loop stops after the first node
  //as no more siblings are found!
  QDomElement myCopy2 = myLayerSetElement2.cloneNode().toElement();
  myLayerSetDoc2.appendChild(myCopy2);
  QString myXml2 = myLayerSetDoc2.toString();
  OmgLayerSet myLayerSet2;
  //now hand over the xml snippet to the layerset class to be deserialised
  if (myLayerSet2.fromXml(myXml2))
  {
    mProjectionLayerSet = myLayerSet2;
  }
  else
  {
    //return false;
  }

  return true;
}

QString OmgModel::toXml() const 
{
  //
  // This does not follow the same schema as libopenmodeller
  // since for the gui we have to serialise the extra properties
  // of the OmgModel class. See toModelCreationXml() and 
  // toModelProjectionXml() fo libom compliant representations
  //
  // Also note that the xml produced below is pretty ugly and 
  // will be completely redesigned in a future release
  //
  QString mySampleCount=QString::number(mLocalities.count());
  QString myString;
  myString += "<Model Guid=\"" + guid() + "\" Completed=\"";
  mCompletedFlag ? myString +="true" : myString += "false";
  myString += "\" Error=\"";
  mErrorFlag ? myString += "true" : myString += "false";
  myString += "\">";
  myString += "<CoordinateSystem>";
  myString +=   "<Name>";
  myString +=     mCoordinateSystemName ;
  myString +=   "</Name>\n";
  myString +=   "<WKT>";
  myString +=     mCoordinateSystem ;
  myString +=   "</WKT>\n";
  myString += "</CoordinateSystem>\n";
  myString += "<Options>\n";
  myString += "  <OccurrencesFilter>\n";
  if (mLocalitiesFilterType==NO_FILTER)
  {
    //add nothing
  }
  else if(mLocalitiesFilterType==SPATIALLY_UNIQUE)
  {
    myString += "    <SpatiallyUnique/>\n";
  }
  else //environmentally unique
  {
    myString += "    <EnvironmentallyUnique/>\n";
  }
  myString += "  </OccurrencesFilter>\n";
  myString += "</Options>\n";
  myString += "<SpeciesFile>";
  myString +=   mSpeciesFile;
  myString += "</SpeciesFile>\n";
  myString += "<TaxonName>";
  myString +=   mTaxonName;
  myString += "</TaxonName>\n";
  myString += "<OutputFormatLayer>";
  myString +=   mOutputFormatLayer.toXml();
  myString += "</OutputFormatLayer>\n";
  myString += "<ProjectionLayerSet>";
  myString +=   mProjectionLayerSet.toXml();
  myString += "</ProjectionLayerSet>\n";
  myString += "<CreationLayerSet>";
  myString +=   mCreationLayerSet.toXml();
  myString += "</CreationLayerSet>\n";
  myString +=   mAlgorithm.toXml();
  //loop through all the localities
  myString += "<Localities>";
  for (int i=0;i<mLocalities.count();i++)
  {
    OmgLocality myLocality = mLocalities.at(i);
    myString+=myLocality.toXml();
  }
  myString +=   "<ShapefileName>" + mShapefileName + "</ShapefileName>";
  myString +=   "<CsvFileName>" + mCsvFileName + "</CsvFileName>";
  myString += "</Localities>\n";
  myString += "<Timing Start=\"" + QString::number(mStartDateTimeStamp.toTime_t()) + "\" "
           +  "End=\"" + QString::number(mEndDateTimeStamp.toTime_t()) + "\"/>\n";
  myString += "<OutputImages>";
  myString +=   "<ThumbnailImage>";
  myString +=     mThumbnailFileName;
  myString +=   "</ThumbnailImage>";
  myString +=   "<PreviewImage>";
  myString +=     mPreviewFileName;
  myString +=   "</PreviewImage>";
  myString +=   "<LegendImage>";
  myString +=     mLegendFileName;
  myString +=   "</LegendImage>";
  myString +=   "<RawImage>";
  myString +=     mRawImageFileName;
  myString +=   "</RawImage>";
  myString +=   "<ModelRasterFormat>";
  myString +=     mModelRasterFormat;
  myString +=   "</ModelRasterFormat>";
  myString +=   "<ColouredImage>";
  myString +=     mColouredImageFileName;
  myString +=   "</ColouredImage>";
  myString += "</OutputImages>";
  myString += "<WorkingDirectory>";
  myString +=   mWorkDir;
  myString += "</WorkingDirectory>";
  myString += "<Definition>";
  myString +=   mModelDefinition;
  myString += "</Definition>";
  myString += "<NormalizationDefinition>";
  myString +=   mNormalizationDefinition;
  myString += "</NormalizationDefinition>";
  myString += "<Stats ";
  myString +=   "RocScore=\"" + QString::number(mRocScore) + "\" " ;
  myString +=   "Accuracy=\"" + QString::number(mAccuracy) + "\" " ;
  myString +=   "Omission=\"" + QString::number(mOmission) + "\" " ;
  myString +=   "Commission=\"" + QString::number(mCommission) + "\" " ;
  myString +=   "PercentCellsPresent=\"" + QString::number(mPercentCellsPresent) + "\" " ;
  myString +=   "TotalCells=\"" + QString::number(mTotalCells) + "\">";
  myString += "  <RocStats>";
  QListIterator< QPair <double,double> > myIterator (mRocPoints);
  while (myIterator.hasNext())
  {
    QPair<double,double> myPair = myIterator.next();
    myString += "  <RocPoint x=\"" + QString::number(myPair.first) + "\" " + 
                            "y=\"" + QString::number(myPair.second) + "\"/>";
  }
  myString += "  </RocStats>";
  myString += "</Stats>";
  myString += "<Log>";
  myString +=   mModelLog;
  myString += "</Log>";
  myString += "</Model>\n";
  return myString;
}
QString OmgModel::toModelCreationXml() const 
{
  //QString myString("<ModelParameters xmlns=\"http://openmodeller.cria.org.br/xml/1.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://openmodeller.cria.org.br/xml/1.0 http://openmodeller.cria.org.br/xml/1.0/openModeller.xsd\">\n");
  //
  // Options
  //
  QString myString = "<Options>\n";
  myString += "  <OccurrencesFilter>\n";
  if (mLocalitiesFilterType==NO_FILTER)
  {
    //add nothing
  }
  else if(mLocalitiesFilterType==SPATIALLY_UNIQUE)
  {
    myString += "      <SpatiallyUnique/>\n";
  }
  else //environmentally unique
  {
    myString += "      <EnvironmentallyUnique/>\n";
  }
  myString += "    </OccurrencesFilter>\n";
  myString += "  </Options>\n";

  //
  // Sampler
  // 

  myString += "  <Sampler>\n";
  myString+=mCreationLayerSet.toXml();
  
  //
  // Presences
  //
  
  myString+=QString("    <Presence Label=\""+mTaxonName+"\">\n");
  myString+=QString("      <CoordinateSystem>\n");
  myString+=QString("         "+mCoordinateSystem+"\n");
  myString+=QString("      </CoordinateSystem>\n");
  //loop through all the localities
  bool myHasAbsencesFlag=false;
  for (int i=0;i<mLocalities.count();i++)
  {
    OmgLocality myLocality = mLocalities.at(i);
    if ( myLocality.abundance() > 0 )
    {
      myString+=myLocality.toXml();
    }
    else
    {
      myHasAbsencesFlag=true;
    }
  }
  myString+=QString("      </Presence>\n");
  
  //
  // Absences
  //
  
  if (myHasAbsencesFlag)
  {
    myString+=QString("    <Absence Label=\""+mTaxonName+"\">\n");
    myString+=QString("      <CoordinateSystem>\n");
    myString+=QString("         "+mCoordinateSystem+"\n");
    myString+=QString("      </CoordinateSystem>\n");
    //loop through all the localities
    for (int i=0;i<mLocalities.count();i++)
    {
      OmgLocality myLocality = mLocalities.at(i);
      if (myLocality.abundance() <= 0)
      {
        myString+=myLocality.toXml();
      }
    }
    myString+=QString("      </Absence>\n");
  }
  //
  // finish up
  //
  
  myString+=QString("  </Sampler>\n");
  myString+=mAlgorithm.toModelCreationXml();
  //myString+=QString("</ModelParameters>\n");
  return myString;
}
QString OmgModel::toModelProjectionXml() const
{
  /* We are trying to make something like this
   * the outer projectionparameters tag will be added by the soap
   * libary, or the local modeler plugin.
   *
  <ProjectionParameters
    xmlns="http://openmodeller.cria.org.br/xml/1.0">
    <Algorithm Id="Bioclim" Version="0.2">
    <Parameters>
    <Parameter Id="StandardDeviationCutoff" Value="0.7"/></Parameters>
    <Model>
    <Bioclim Mean="221.6 2375.984008789062" StdDev="93.9951700886806
    184.4701277015361" Minimum="90 1911.670043945312" Maximum="413
    2565.010009765625"/></Model></Algorithm>
    <Environment NumLayers="2">
    <Map
    Id="/home/renato/projects/openmodeller/examples/layers/rain_coolest"
    IsCategorical="0" Min="0" Max="2137"/>
    <Map Id="/home/renato/projects/openmodeller/examples/layers/temp_avg"
    IsCategorical="0" Min="-545.4199829101562" Max="3342.52001953125"/>
    <Mask
    Id="/home/renato/projects/openmodeller/examples/layers/rain_coolest"/>
    </Environment>
    <OutputParameters FileType="DoubleingTiff">
    <TemplateLayer
    Id="/home/renato/projects/openmodeller/examples/layers/rain_coolest"/>
    </OutputParameters>
   </ProjectionParameters>
   */
   QString myString=mAlgorithm.toModelProjectionXml(mModelDefinition,mNormalizationDefinition);
   myString+=mProjectionLayerSet.toXml();
   myString+="\n<OutputParameters FileType=\"" + mModelRasterFormat + "\">";
   myString+="\n<TemplateLayer Id=\"" + mOutputFormatLayer.name() + "\"/>";  
   myString+="\n</OutputParameters>";
   return myString;
}  
QString OmgModel::projectionLayersXml() 
{
  return mProjectionLayerSet.toXml();
}

QString OmgModel::toHtml(bool theForceFlag) const
{
  //make sure the working dir for the expreiment exists
  QDir myWorkDir(mWorkDir);
  //QString.replace() is destructive so make a copy first
  QString myTaxonName = mTaxonName;
  myTaxonName.replace(" ","_");
  QString myOutputFileName(mWorkDir + "/" + myTaxonName + "_report.html");
  if (!myWorkDir.exists())
  {
    qDebug(QObject::tr("Working directory does not exist...html not saved"));
    return "";
  }
  else //save it out to file
  {
    qDebug(QObject::tr("Saving experiment report as html"));
    if (QFile::exists(myOutputFileName) && !theForceFlag)
    return myOutputFileName;
  }
  QString myAlgorithmParameters = mAlgorithm.toHtml();
  QString myStatsString;
  myStatsString += "<p>" + QObject::tr("Area Under Curve (AUC): ") +
     QString::number( mRocScore,'f',2 ) + "<br />\n";
  myStatsString += QObject::tr("Accuracy : ") +
     QString::number( mAccuracy ) + QObject::tr("% (using 50% threshold)") + "<br />\n";
  myStatsString += QObject::tr("Omission error : ") +
     QString::number( mOmission ) + QObject::tr("% (using 50% threshold)") + "<br />\n";
  //only valid for models with absence data
  myStatsString += QString( "Commission error : ");
     QString::number( mCommission ) + QObject::tr("% (using 50% threshold)") + "<br />\n";
  myStatsString += QObject::tr("Percentage of cells predicted present : ") 
    + QString::number ( mPercentCellsPresent ) + "%<br />\n";
  myStatsString += QObject::tr("Total number of cells : ")
    + QString::number( mTotalCells ) + "</p>\n";
  //make an image of the roc curve
  myStatsString+= QString("<h3 align=\"center\" class=\"glossy\"><a name=\"roc_curve\"></a>" + QObject::tr("ROC Curve:") + "</h3>\n");
  createRocGraph(theForceFlag);
  myStatsString+=QString("<p><img src=\"" + myTaxonName + "_roc_curve.png\"></p>\n");
  //make a table of the roc curve
  myStatsString += "<table class=\"rocTable\">\n"; //qt 4.3 seems to ignore table css
  QString myCounterString("<tr>\n");
  myCounterString += "<th class=\"glossy\">" + QObject::tr("No.") + "\n";
  myCounterString += "</th>\n";
  QString myXString ("<tr>\n");
  myXString += "<th>X\n";
  myXString += "</th>\n";
  QString myYString ("<tr>\n");
  myYString += "<th>Y\n";
  myYString += "</th>\n";
  unsigned int myCounter = 1;
  bool myAlternateCell=false; //for highlighting every other row
  QListIterator< QPair <double,double> > myRocIterator (mRocPoints);
  while (myRocIterator.hasNext())
  {
    QPair<double,double> myPair = myRocIterator.next();
    myCounterString += "<td class=\"glossy\">" + QString::number(myCounter) + "</td>\n";
    QString myTd;
    if (myAlternateCell)
    {
      myTd = "<td>"; 
      myAlternateCell=false;
    }
    else
    {
      myTd = "<td class=\"alternateCell\">"; 
      myAlternateCell=true;
    }
    myXString += myTd + QString::number(myPair.first,'f',3) + " </td>\n";
    myYString += myTd + QString::number(myPair.second,'f',3) + " </td>\n";

    ++myCounter;
  }
  myCounterString += "</tr>\n";
  myXString += "</tr>\n";
  myYString += "</tr>\n";
  myStatsString += myCounterString; 
  myStatsString += myXString;
  myStatsString += myYString; 
  myStatsString += "</table>\n";

  //
  // make a histogram of the distribution of probabilities
  // 
  myStatsString+="<br/>\n";
  QFileInfo myRasterFileInfo(workDir() + rawImageFileName());
  if (!myRasterFileInfo.exists())
  {
    qDebug("Model projection does not exist, no raster related summary will be generated");
  }
  else if (100==1) //disable for now
  {
    myStatsString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"probability_dist\"></a>" + QObject::tr("Distribution of probabilities:") + "</h3>\n");

    QgsRasterLayer * mypRasterLayer = new QgsRasterLayer(myRasterFileInfo.filePath(), 
      myRasterFileInfo.completeBaseName());
    const int myBinCount=10;
    bool myIgnoreOutOfRangeFlag=true;
    bool myThoroughBandScanFlag=true;
    const int myCurrentBand=1; //base 1!
    const int myUpperThreshold=254; //we will ignore eny value over this
    const int myLowerThreshold=0; //we will ignore eny value under this
    OmgDataSeries myRasterSeries;
    myRasterSeries.setLabel("Probability");

    mypRasterLayer->populateHistogram(myCurrentBand,myBinCount,myIgnoreOutOfRangeFlag,myThoroughBandScanFlag); 
    QgsRasterBandStats myRasterBandStats = mypRasterLayer->getRasterBandStats(myCurrentBand);
    for (int myBin = 0; myBin < myBinCount; myBin++)
    {
      double myValue = static_cast<double> ( myRasterBandStats.histogramVector->at(myBin) );
      if (myValue <= myUpperThreshold && myValue >= myLowerThreshold)
      {
        //myValue = 0;
        continue;
      }
      myRasterSeries << myValue;
    }
    QImage myRasterImage = QImage( 400,400,QImage::Format_ARGB32 );
    myRasterImage.fill(Qt::white);
    QPainter myRasterPainter ( &myRasterImage );
    OmgGraph myRasterGraph(&myRasterPainter);
    myRasterSeries.setFillColor(Qt::red);
    myRasterSeries.setLineColor(Qt::darkGray);
    myRasterGraph.addSeries(myRasterSeries);
    myRasterGraph.setVerticesEnabled(false);
    myRasterGraph.setVertexLabelsEnabled(false);
    myRasterGraph.setAreaFillEnabled(true);
    myRasterGraph.setSpliningEnabled(false);
    myRasterGraph.setGridLinesEnabled(true);
    myRasterGraph.render();
    myRasterImage.save(mWorkDir + "/" + myTaxonName + "_probability_histogram.png");
    myStatsString+=QString("  <p><img src=\"" + myTaxonName + "_probability_histogram.png\"></p>\n");
    //show other raster stats
    myStatsString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"probability_dist\"></a>" + QObject::tr("Output Projection Raster Properties:") + "</h3>\n");
    myStatsString += "<p>" + mypRasterLayer->getMetadata() + "</p>";
    //continue on with the rest of the report now.
  }

  //
  // Main report starts here
  //
  QString myString;
  myString+=Omgui::getHtmlHeader();
  myString+=QString("  <br/>\n");
  myString+=QString("  <table border=\"0\">\n");
  myString+=QString("  <tr>\n");
  myString+=QString("    <td rowspan=\"9\"><img src=\""+mThumbnailFileName+"\"></td>\n");
  myString+=QString("    <td rowspan=\"9\">&nbsp;&nbsp;</td>\n");
  myString+=QString("    <td colspan=\"2\"><h1>" + 
      QObject::tr("openModeller Model Report") + "</h1>\n</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\n");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Taxon:") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\"><i>"+mTaxonName+"</i></td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\n");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Algorithm:") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+mAlgorithm.name()+"</td>\n");
  myString+=QString("  </tr>\n\n");  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Started: ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+mStartDateTimeStamp.toString()+"</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Completed: ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+mEndDateTimeStamp.toString()+"</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Processing time: ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+
    Omgui::secondsToString <long> (mStartDateTimeStamp.secsTo(mEndDateTimeStamp),Omgui::longTimeForm) + 
      "</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\n\n");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Raster Format: ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" +
    Omgui::getOutputFormatNotes().value(mModelRasterFormat) +
      "</td>\n");
  myString+=QString("  </tr>\n\n");


  //
  // Occurrence filtering options
  //
  myString +="  <tr>\n\n";
  myString +="    <td class=\"headerCell\"> " + 
      QObject::tr("Occurrence filtering: ") + "</td>\n";
  myString +="    <td class=\"largeCell\">";
  if (mLocalitiesFilterType==NO_FILTER)
  {
    myString += QObject::tr("Unfiltered");
  }
  else if(mLocalitiesFilterType==SPATIALLY_UNIQUE)
  {
    myString += QObject::tr("Spatially Unique");
  }
  else //environmentally unique
  {
    myString += QObject::tr("Environmentally Unique");
  }
  myString += "   </td>\n";
  myString +="  </tr>\n\n";
  myString+=QString("  <tr>\n");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Model Globally Unique Identifier:") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+guid()+"</td>\n");
  myString+=QString("  </tr>\n\n");  
  myString+=QString("  </table>\n");
  myString+=QString("  <table>\n");
  myString+=QString("  <tr valign=\"top\">\n"); 
  myString+=QString("    <td>\n");
  myString+=QString("      <ul>\n");
  myString+=QString("        <li><a href=\"#outputmap\" > " + QObject::tr("Output map") + "</a></li>\n");
  myString+=QString("        <li><a href=\"#modelstats\" > " + QObject::tr("Model statistics") + "</a></li>\n");
  myString+=QString("      </ul>\n");
  myString+=QString("    </td>\n");
  myString+=QString("    <td>\n");
  myString+=QString("      <ul>\n");
  myString+=QString("        <li><a href=\"#algparameters\" > " + QObject::tr("Algorithm parameters") + "</a></li>\n");
  myString+=QString("        <li><a href=\"#creationlayers\" > " + QObject::tr("Environmental layers") + "</a></li>\n");
  myString+=QString("      </ul>\n");
  myString+=QString("    </td>\n");
  myString+=QString("  </tr>\n");
  myString+=QString("  </table>\n");
  myString+=QString("  <a name=\"outputmap\"></a> ");
  myString+=QString("  <h3 align=\"center\" class=\"glossy\">" + QObject::tr("Output map:") + "</h3>\n");
  myString+=QString("  <p><img src=\""+mPreviewFileName+"\"></p>\n");
  myString+=QString("  <p><img src=\""+mLegendFileName+"\"></p>\n");
  myString+=QString("  <h3 align=\"center\" class=\"glossyh3\"><a name=\"modelstats\"></a> " + QObject::tr("Output statistics:") + "</h3>\n");
  myString+= myStatsString + "\n";
  //myString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"modeldef\"></a>Model definition:</h3>\n"); 
  //myString+=QString("  <p>"+mModelDefinition+"</p>\n");
  myString+=QString("  <a name=\"algparameters\"></a>\n");  
  myString+=QString("  <p>"+myAlgorithmParameters+"</p>\n");
  /*
  myString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"inputlocalities\"></a> " + QObject::tr("Input localities:") + "</h3>\n");  
  myString+=QString("  <table border=\"1\">\n"); 
  myString+=QString("    <tr>\n");
  myString+=QString("      <th>#</th><th> " + QObject::tr("Id") + "</th><th> " + QObject::tr("Lat") + "</th><th> " + QObject::tr("Long") + "</th>");
  QStringListIterator myIterator(creationLayerNames());
  while (myIterator.hasNext())
  {       
    QFileInfo myFileInfo(myIterator.next());
    myString+=QString("<th>"+myFileInfo.baseName()+"</th>");
  }
  myString+="\n";
  myString+=QString("    </tr>\n");

  for (int myRow = 0; myRow < localities().size(); ++myRow) 
  {
    myString+=QString("    <tr>\n");
    OmgLocality myLocality = localities().at(myRow);
    myString += "      <td>" + QString::number(myRow) + "</td>";
    myString += "<td>" + myLocality.id() + "</td>";
    myString += "<td>" + QString::number(myLocality.longitude()) + "</td>";
    myString += "<td>" + QString::number(myLocality.latitude()) + "</td>";
    for (int myCol = 0; myCol < myLocality.samples().size(); ++myCol) 
    {
      double mySample = myLocality.samples().at(myCol);
      myString += "<td>" + QString::number(mySample) + "</td>";
    }
    myString+=QString("\n    </tr>\n");
  }
  myString+=QString("  </table>\n"); 
  */
  myString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"creationlayers\"></a> " + QObject::tr("Model Creation Layers:") + "</h3>\n");  
  myString+=mCreationLayerSet.toHtml(); 
  myString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"projectionlayers\"></a> " + QObject::tr("Model Projection Layers:") + "</h3>\n");  
  myString+=mProjectionLayerSet.toHtml();
  myString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"formatlayer\"></a> " + QObject::tr("Format Layer:") + "</h3>\n");  
  myString += "<p>" + mOutputFormatLayer.name() + "</p>\n";
  myString+=QString("  <h3 align=\"center\" class=\"glossy\"><a name=\"modellog\"></a> " + QObject::tr("Model Log") + "</h3>\n");
  myString+=QString("<pre>" + mModelLog + "</pre>");
  myString+=Omgui::getHtmlFooter();
  Omgui::createTextFile(myOutputFileName , myString);
  return myOutputFileName;
}

QString OmgModel::toPrintHtml(bool theForceFlag) const
{
  //QString.replace() is destructive so make a copy first
  QString myTaxonName = mTaxonName;
  myTaxonName.replace(" ","_");
  QString myAlgorithmParameters = mAlgorithm.toHtml();
  QString myStatsString;
  //make an image of the roc curve
  myStatsString+= QString("<h3 align=\"center\" class=\"glossy\"><a name=\"roc_curve\"></a>" + QObject::tr("ROC Curve:") + "</h3>\n");
  createRocGraph(theForceFlag);
  myStatsString+=QString("<p><img src=\"" + mWorkDir + QDir::separator() +
      myTaxonName + "_roc_curve.png\"></p>\n");
  //make a table of the roc curve
  myStatsString += "<table class=\"rocTable\">\n";
  QString myCounterString("<tr>\n");
  myCounterString += "<th>" + QObject::tr("No.") + "\n";
  myCounterString += "</th>\n";
  QString myXString ("<tr>\n");
  myXString += "<th>X\n";
  myXString += "</th>\n";
  QString myYString ("<tr>\n");
  myYString += "<th>Y\n";
  myYString += "</th>\n";
  unsigned int myCounter = 1;
  QListIterator< QPair <double,double> > myRocIterator (mRocPoints);
  while (myRocIterator.hasNext())
  {
    QPair<double,double> myPair = myRocIterator.next();
    myCounterString += "<td>" + QString::number(myCounter) + "</td>\n";
    myXString += "<td>" + QString::number(myPair.first) + "</td>\n";
    myYString += "<td>" + QString::number(myPair.second) + "</td>\n";
    ++myCounter;
  }
  myCounterString += "</tr>\n";
  myXString += "</tr>\n";
  myYString += "</tr>\n";
  myStatsString += myCounterString; 
  myStatsString += myXString;
  myStatsString += myYString; 
  myStatsString += "</table>\n";

  myStatsString+="<br/>\n";

  //
  // Main report starts here
  //
  QString myString;
  myString+=QString("  <br/>\n");
  myString+=QString("  <h3 align=\"center\" class=\"glossy\">" + mTaxonName + " - " + mAlgorithm.name() + "</h3>\n");
  myString+=QString("  <table width=\"100%\">\n");
  myString+=QString("  <tr>\n");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Taxon :") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\"><i>"+mTaxonName+"</i></td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\n");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Algorithm :") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+mAlgorithm.name()+"</td>\n");
  myString+=QString("  </tr>\n\n");  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Started: ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+mStartDateTimeStamp.toString()+"</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Completed : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+mEndDateTimeStamp.toString()+"</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Processing time : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+
    Omgui::secondsToString <long> (mStartDateTimeStamp.secsTo(mEndDateTimeStamp),Omgui::longTimeForm) + 
      "</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Raster Format: ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" +
    Omgui::getOutputFormatNotes().value(mModelRasterFormat) + 
      "</td>\n");
  myString+=QString("  </tr>\n\n");

  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Area Under Curve (AUC) : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">"+ QString::number( mRocScore,'f',2 )
      + "</td>\n");
  myString+=QString("  </tr>\n\n");

  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Accuracy : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + QString::number( mAccuracy ) + "%"
      + QObject::tr(" (using 50% threshold)")
      + "</td>\n");
  myString+=QString("  </tr>\n\n");
  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Omission error : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + QString::number( mOmission )
      + QObject::tr(" (using 50% threshold)")
      + "</td>\n");
  myString+=QString("  </tr>\n\n");
  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Commission error : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + QString::number( mCommission ) + "%" 
      + QObject::tr(" (using 50% threshold)")
      + "</td>\n");
  myString+=QString("  </tr>\n\n");
  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Cells predicted present : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + QString::number ( mPercentCellsPresent ) + "%"
      + "</td>\n");
  myString+=QString("  </tr>\n\n");
  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Total number of cells : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + QString::number( mTotalCells )
      + "</td>\n");
  myString+=QString("  </tr>\n\n");
  
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Model Creation Layerset : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + mCreationLayerSet.name() + "</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Model Projection Layerset : ") + "</td>\n");
  myString+=QString("    <td class=\"largeCell\">" + mProjectionLayerSet.name() + "</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  <tr>\b");
  myString+=QString("    <td class=\"headerCell\"> " + QObject::tr("Format Layer : ") + "</td>\n");
  QString myName = mOutputFormatLayer.name();
  myName.replace("\\"," \\"); //for word wrapping in cell
  myName.replace("/"," /"); //for word wrapping in cell
  myString+=QString("    <td class=\"largeCell\">" + myName + "</td>\n");
  myString+=QString("  </tr>\n\n");
  myString+=QString("  </table>\n");
  myString+=QString("  <a name=\"outputmap\"></a> ");
  myString+=QString("  <h3 align=\"center\" class=\"glossy\">" + QObject::tr("Output map:") + "</h3>\n");
  myString+=QString("  <p><img src=\""+ mWorkDir + QDir::separator() +mPreviewFileName+"\"></p>\n");
  myString+=QString("  <p><img src=\""+ mWorkDir + QDir::separator() +mLegendFileName+"\"></p>\n");
  myString+=QString("  <h3 align=\"center\" class=\"glossy\">" + QObject::tr("Output statistics:") + "</h3>\n");
  myString+= myStatsString + "\n";
  return myString;
}

void OmgModel::createRocGraph(bool theForceFlag) const 
{
  QImage myImage = QImage( 200,200,QImage::Format_ARGB32 );
  myImage.fill(Qt::white);
  QPainter myPainter ( &myImage );
  OmgGraph myGraph(&myPainter);
  OmgDataSeries mySeries = getRocPoints();
  mySeries.setLineColor(Qt::darkGray);
  mySeries.setFillColor(QColor("#3087d3"));
  myGraph.addSeries(mySeries);
  myGraph.setVerticesEnabled(false);
  myGraph.setVertexLabelsEnabled(false);
  myGraph.setAreaFillEnabled(true);
  myGraph.setSpliningEnabled(false);
  myGraph.setGridLinesEnabled(true);
  myGraph.setDiagonalEnabled();
  myGraph.render();
  QString myTaxonName = mTaxonName;
  myTaxonName.replace(" ","_");
  QString myFileName = mWorkDir + QDir::separator() + myTaxonName + "_roc_curve.png";
  qDebug ("Saving roc graph to " + myFileName.toLocal8Bit());
  myImage.save(myFileName,"PNG");
}


void OmgModel::addRocPoint( QPair <double,double> thePair )
{
  mRocPoints << thePair;
}

void OmgModel::clearRocPoints()
{
  mRocPoints.clear();
}

OmgDataSeries OmgModel::getRocPoints() const
{
  OmgDataSeries mySeries;
  mySeries.setLabel( QObject::tr("Roc Curve") );
  QListIterator< QPair <double,double> > myIterator (mRocPoints);
  while (myIterator.hasNext())
  {
         QPair<double,double> myPair = myIterator.next();
         mySeries << myPair;
  }
  return mySeries;
}

void OmgModel::setModelRasterFormat(QString theFormat)
{
  //check that its a valid format
  if (Omgui::getOutputFormats().contains(theFormat))
  {
    mModelRasterFormat=theFormat;
  }
  else
  {
    qDebug("Attempting to set model format to an invalid format"
        "...using default GreyTiff");
  }

}
QString OmgModel::modelRasterFormat() const
{
  return mModelRasterFormat;
}

QString OmgModel::localitiesToCsv(QString theDelimiter) const
{
  QString myString= "#Num,Lat,Long";
  QStringListIterator myIterator(creationLayerNames());
  while (myIterator.hasNext())
  {       
    QFileInfo myFileInfo(myIterator.next());
    myString+=QString(","+myFileInfo.baseName());
  }
  for (int myRow = 0; myRow < localities().size(); ++myRow) 
  {
    myString+="\n";
    OmgLocality myLocality = localities().at(myRow);
    myString += myLocality.id() + theDelimiter;
    myString += QString::number(myLocality.longitude()) + theDelimiter;
    myString += QString::number(myLocality.latitude()) ;
    for (int myCol = 0; myCol < myLocality.samples().size(); ++myCol) 
    {
      double mySample = myLocality.samples().at(myCol);
      myString += theDelimiter + QString::number(mySample);
    }
  }
  return myString;
}

bool OmgModel::toShapefile(QString theShapefileName) const
{
  return Omgui::localitiesToShapefile(theShapefileName,mLocalities);
}
//mutators

void OmgModel::setLocalities(OmgLocalities theLocalities)
{
   mLocalities = theLocalities; 
}

void OmgModel::setCoordinateSystem(const QString theCoordinateSystem)
{
  mCoordinateSystem = theCoordinateSystem;
}
void OmgModel::setCoordinateSystemName (const QString theName)
{
  mCoordinateSystemName = theName;
}

void OmgModel::setSpeciesFile(const QString theSpeciesFile)
{
  mSpeciesFile = theSpeciesFile;
}
void OmgModel::setShapefileName(const QString theShapefileName)
{
  QFileInfo myFileInfo(theShapefileName);
  mShapefileName = myFileInfo.fileName();
}
void OmgModel::setCsvFileName(const QString theCsvFileName)
{
  QFileInfo myFileInfo(theCsvFileName);
  mCsvFileName = myFileInfo.fileName();
}
void OmgModel::setLocalitiesFilterType(LocalitiesFilterType theFilterType)
{
  mLocalitiesFilterType = theFilterType;
}
OmgModel::LocalitiesFilterType OmgModel::localitiesFilterType() const
{
  return mLocalitiesFilterType;
}

unsigned int OmgModel::loadLocalities()
{
  unsigned int myCounter=0;
  //
  // NOTE the code below deuplicates from a bunch of code in omgmodeldesigner
  // the logic should rather be moved into a shared place - perhaps omgspeciesfile
  //

  //
  // Now that we have the localities text file, we need to parse it and find
  //
  //first creation a regex to match text at the beginning of the line
  QRegExp myQRegExp( "^[^#][ a-zA-Z]*" ); //second caret means 'not'
  QFile myQFile( mSpeciesFile );
  if ( myQFile.open( QIODevice::ReadOnly ) )
  {
    mLocalities.clear();
    //now we parse the loc file, checking each line for its taxon
    QTextStream myQTextStream( &myQFile );
    QString myCurrentLine;
    while ( !myQTextStream.atEnd() )
    {
      myCurrentLine = myQTextStream.readLine(); // line of text excluding '\n'
      //split on word boundaries ignoring empty parts
      QStringList myList = myCurrentLine.split(QRegExp("[\t]"));
      //qDebug("Read line : " + myList.join(" -- ").toLocal8Bit());
      if (myCurrentLine.startsWith("#"))
      {
        continue;
      }
      if (myList.size() < 4)
      {
        continue;
      }
      else //new 'proper' format file that has #id \t species name \t lon \t lat
      {
        QString myId=myList.at(0).simplified();
        QString myTaxonName=myList.at(1).simplified();
        //make sure there are only single spaces separating words.
        myTaxonName=myTaxonName.replace( QRegExp(" {2,}"), " " );
        //if this taxon name matches, add its locality to the localites collection
        if (myTaxonName==mTaxonName)
        {
          OmgLocality myLocality;
          myLocality.setId(myId);
          myLocality.setLabel(myTaxonName);
          myLocality.setLongitude(myList.at(2).simplified().toDouble());
          myLocality.setLatitude(myList.at(3).simplified().toDouble());
          if (myList.size()>4) //abundance
          {
            myLocality.setAbundance(myList.at(4).simplified().toDouble());
          }
          if (myLocality.isValid())
          {
            ++myCounter;
            mLocalities.push_back(myLocality);
          }
        }
      }
    }
    myQFile.close();
  }
  else
  {
    //qDebug("An error occurred in OmgModel while trying to load the localities");
    return myCounter;
  }
  return myCounter;
}

void OmgModel::setTaxonName(const QString theName)
{
  mTaxonName = theName;
}

void OmgModel::setCreationLayerSet(OmgLayerSet theLayerSet)
{
  mCreationLayerSet=theLayerSet;
}
void OmgModel::setProjectionLayerSet(OmgLayerSet theLayerSet)
{
  mProjectionLayerSet=theLayerSet;
}
void OmgModel::setcreationMaskLayerName(QString theName)
{
  //qDebug("setcreationMaskLayerName " + theName.toLocal8Bit());
  OmgLayer myLayer;
  myLayer.setName(theName);
  myLayer.setCategorical(false);
  mCreationLayerSet.setMask(myLayer); 
}
void OmgModel::setProjectionMaskLayerName(QString theName)
{
  //qDebug("setProjectMaskLayerName " + theName.toLocal8Bit());
  OmgLayer myLayer;
  myLayer.setName(theName);
  myLayer.setCategorical(false);
  mProjectionLayerSet.setMask(myLayer); 
}
void OmgModel::setOutputFormatLayerName(QString theName)
{
  //qDebug("setOutputFormatLayerName " + theName.toLocal8Bit());
  mOutputFormatLayer.setName(theName);
  mOutputFormatLayer.setCategorical(false);
}
void OmgModel::setCreationLayerNames(QStringList theNames)
{
  //qDebug("setCreationLayerNames " + theNames.join(",").toLocal8Bit());
  QStringListIterator myIterator(theNames);
  while (myIterator.hasNext())
  {
    QString myString = myIterator.next();
    OmgLayer myLayer;
    myLayer.setName(myString);
    myLayer.setCategorical(false);
    mCreationLayerSet.addLayer(myLayer);
  }
}
void OmgModel::setProjectionLayerNames(QStringList theNames)
{
  //qDebug("setCreationLayerNames" + theNames.join(",").toLocal8Bit());
  QStringListIterator myIterator(theNames);
  while (myIterator.hasNext())
  {
    QString myString = myIterator.next();
    OmgLayer myLayer;
    myLayer.setName(myString);
    myLayer.setCategorical(false);
    mProjectionLayerSet.addLayer(myLayer);
  }
}
void OmgModel::setAlgorithm(OmgAlgorithm theAlgorithm)
{
  //qDebug("setAlgorithm" + theAlgorithm.name().toLocal8Bit());
  mAlgorithm = theAlgorithm;
}
void OmgModel::setError(bool theFlag)
{
  mErrorFlag=theFlag;
}
void OmgModel::setCompleted(bool theFlag)
{
  mCompletedFlag=theFlag;
}
void OmgModel::setStartDateTimeStamp(QDateTime theDateTimeStamp)
{
  mStartDateTimeStamp=theDateTimeStamp; 
}
void OmgModel::setEndDateTimeStamp(QDateTime theDateTimeStamp)
{
  mEndDateTimeStamp=theDateTimeStamp; 
}
void OmgModel::setThumbnailFileName(QString theFileName)
{
  QFileInfo myFileInfo(theFileName);
  mThumbnailFileName=myFileInfo.fileName();
}
void OmgModel::setPreviewFileName(QString theFileName)
{
  QFileInfo myFileInfo(theFileName);
  mPreviewFileName=myFileInfo.fileName();
}
void OmgModel::setLegendFileName(QString theFileName)
{
  QFileInfo myFileInfo(theFileName);
  mLegendFileName=myFileInfo.fileName();
}
void OmgModel::setRawImageFileName(QString theFileName)
{
  QFileInfo myFileInfo(theFileName);
  mRawImageFileName=myFileInfo.fileName();
}
void OmgModel::setColouredImageFileName(QString theFileName)
{
  QFileInfo myFileInfo(theFileName);
  mColouredImageFileName=myFileInfo.fileName();
}

void OmgModel::setWorkDir(QString theDir)
{
  //ensure we have a dir and an ending slash
  QFileInfo myFileInfo(theDir);
  mWorkDir=myFileInfo.absoluteFilePath() + QDir::separator();
}

void OmgModel::setRocScore(double theRocScore)
{
  mRocScore=theRocScore;
}
void OmgModel::setAccuracy(double theAccuracy)
{
  mAccuracy=theAccuracy;
}
void OmgModel::setOmission(double theOmission)
{
  mOmission=theOmission;
}
void OmgModel::setCommission(double theCommission)
{
  mCommission=theCommission;
}
void OmgModel::setPercentCellsPresent(double thePercent )
{
  mPercentCellsPresent=thePercent;
}
void OmgModel::setTotalCells(double theTotal)
{
  mTotalCells=theTotal;
}
void OmgModel::setModelDefinition(QString theDefinition)
{
  mModelDefinition = theDefinition;
}

void OmgModel::setNormalizationDefinition(QString theDefinition)
{
  mNormalizationDefinition = theDefinition;
}
void OmgModel::appendToLog(QString theMessage)
{
  mModelLog += theMessage + "\n";
}

void OmgModel::setLog(QString theLog)
{
  mModelLog = theLog;
}
//accessors

OmgLocalities OmgModel::localities() const
{
  return mLocalities;
}
QString OmgModel::coordinateSystem() const
{
  return mCoordinateSystem;
}

QString OmgModel::coordinateSystemName() const
{
  return mCoordinateSystemName;
}

QString OmgModel::speciesFile() const
{
  return mSpeciesFile;
}

QString OmgModel::shapefileName() const
{
  QFileInfo myFileInfo(mShapefileName);
  QString myFileName=myFileInfo.fileName();
  return myFileName;
}

QString OmgModel::csvFileName() const
{
  return mCsvFileName;
}

QString OmgModel::taxonName() const
{
  return mTaxonName;
}

OmgLayerSet OmgModel::creationLayerSet() const
{
  return mCreationLayerSet; 
}
OmgLayerSet OmgModel::projectionLayerSet() const
{
  return mProjectionLayerSet;
}
QString OmgModel::creationMaskLayerName() const
{
  return mCreationLayerSet.maskName();
}
QString OmgModel::projectionMaskLayerName() const
{
  return mProjectionLayerSet.maskName();
}
QString OmgModel::outputFormatLayerName() const
{
  return mOutputFormatLayer.name();
}
QStringList OmgModel::creationLayerNames() const
{
  return mCreationLayerSet.nameList();
}
QStringList OmgModel::projectionLayerNames() const
{
  return mProjectionLayerSet.nameList();
}
OmgAlgorithm OmgModel::algorithm() const
{
  return mAlgorithm;
}
bool OmgModel::hasError() const
{
  return mErrorFlag;
}
bool OmgModel::isCompleted() const
{
  return mCompletedFlag;
}
QDateTime OmgModel::startDateTimeStamp() const
{
  return mStartDateTimeStamp;
}
QDateTime OmgModel::endDateTimeStamp() const
{
  return mEndDateTimeStamp;
}
QString OmgModel::thumbnailFileName() const
{
  return mThumbnailFileName;
}
QString OmgModel::previewFileName() const
{
  return mPreviewFileName;
}
QString OmgModel::legendFileName() const
{
  return mLegendFileName;
}
QString OmgModel::rawImageFileName() const
{
  // This if test seems refundant but I was
  // getting a crash before adding it
  if (!mRawImageFileName.isEmpty())
  {
    return mRawImageFileName;
  }
  else
  {
    return QString();
  }
}
QString OmgModel::colouredImageFileName() const
{
  return mColouredImageFileName;
}

QString OmgModel::workDir() const
{
  return mWorkDir;
}
double OmgModel::rocScore() const
{
  return mRocScore; 
}
double OmgModel::accuracy() const
{
  return mAccuracy; 
}
double OmgModel::omission() const
{
  return mOmission; 
}
double OmgModel::commission() const
{
  return mCommission; 
}
double OmgModel::percentCellsPresent() const
{
 return mPercentCellsPresent; 
}
double OmgModel::totalCells() const
{
 return mTotalCells; 
}

QString OmgModel::modelDefinition() const
{
  return mModelDefinition;
}

QString OmgModel::normalizationDefinition() const
{
  return mNormalizationDefinition;
}

QString OmgModel::modelLog() const
{
  return mModelLog;
}

void OmgModel::createThumbnail()
{
  //
  // now get a thumbnail of the projection image and paste it into our
  // painter
  QFileInfo myFileInfo(rawImageFileName());
  QString myBaseName = myFileInfo.baseName();
  QString myImageFileName = mWorkDir + 
    QDir::separator() + 
    myBaseName + "_preview.png";
  myFileInfo = QFileInfo(myImageFileName);
  if (!myFileInfo.exists())
  {
    //we will use a model failed or model not run icons
    //since the model image does not exist
    if (!isCompleted())
    {
      if (hasError())
      {
        myImageFileName = ":/status_aborted.png";
      }
      else
      {
        //show queued icon
        myImageFileName = ":/status_queued.png";
      }
    }
    else
    {
      // Image not found for some other reason - it should exist
      myImageFileName = ":/non_categorical.png";
    }
  }
  QString myThumbImageName = mWorkDir + QDir::separator() + 
    myBaseName + "_thumb.png";
  Omgui::createThumbnail(mTaxonName,
    mAlgorithm.name(),
    myImageFileName,
    myThumbImageName);
 
  setThumbnailFileName(myThumbImageName);
}

bool OmgModel::parseModelResult(QString theModelXml)
{
  //qDebug("******** Parsing model result ***********");
  //Omgui::createTextFile("/tmp/model.xml",theModelXml);
  QDomDocument myDocument("mydocument");
  myDocument.setContent(theModelXml);
  QDomElement myTopElement = myDocument.firstChildElement("SerializedModel");
  if (myTopElement.isNull())
  {
    //qDebug("Top (SerializedModel) element could not be found!");
    return false;
  }
  QDomElement mySamplerElement = myTopElement.firstChildElement("Sampler");
  if (mySamplerElement.isNull())
  {
    //qDebug("Sampler element could not be found!");
    return false;
  }
  
  //
  // Parse for presence records
  //
  OmgLocalities myLocalities; //used by absence parser too...
  QDomElement myPresenceElement = mySamplerElement.firstChildElement("Presence");
  if (!myPresenceElement.isNull())
  {
    QDomElement myElement = myPresenceElement.firstChildElement();
    while(!myElement.isNull()) 
    {
      if (myElement.tagName()!="Point")
      {
        myElement = myElement.nextSiblingElement();
        continue;
      }
      //qDebug("Parser found a point");
      OmgLocality myLocality;
      QString myId=myElement.attribute("Id");
      myLocality.setId(myId);
      QString myX=myElement.attribute("X");
      myLocality.setLongitude(myX.toDouble());
      QString myY=myElement.attribute("Y");
      myLocality.setLatitude(myY.toDouble());
      QString mySample=myElement.attribute("Sample");
      //qDebug("Sample for point: " + mySample.toLocal8Bit());
      QStringList myList=mySample.split(" ");
      QStringListIterator myIterator(myList);
      OmgSampleVector mySamples;
      while (myIterator.hasNext())
      {
        double myDouble=myIterator.next().toDouble();
        mySamples.push_back(myDouble);
      }
      myLocality.setSamples(mySamples);
      myLocalities.push_back(myLocality);
      myElement = myElement.nextSiblingElement();
    }
  }
  //
  // Parse for absences
  //
  QDomElement myAbsenceElement = mySamplerElement.firstChildElement("Absence");
  if (!myAbsenceElement.isNull())
  {
    QDomElement myElement = myAbsenceElement.firstChildElement();
    while(!myElement.isNull()) 
    {
      if (myElement.tagName()!="Point")
      {
        myElement = myElement.nextSiblingElement();
        continue;
      }
      //qDebug("Parser found a point");
      OmgLocality myLocality;
      myLocality.setAbundance(0);
      QString myId=myElement.attribute("Id");
      myLocality.setId(myId);
      QString myX=myElement.attribute("X");
      myLocality.setLongitude(myX.toDouble());
      QString myY=myElement.attribute("Y");
      myLocality.setLatitude(myY.toDouble());
      QString mySample=myElement.attribute("Sample");
      //qDebug("Sample for point: " + mySample.toLocal8Bit());
      QStringList myList=mySample.split(" ");
      QStringListIterator myIterator(myList);
      OmgSampleVector mySamples;
      while (myIterator.hasNext())
      {
        double myDouble=myIterator.next().toDouble();
        mySamples.push_back(myDouble);
      }
      myLocality.setSamples(mySamples);
      myLocalities.push_back(myLocality);
      myElement = myElement.nextSiblingElement();
    }
  }
  setLocalities(myLocalities);
  //
  // Extract the serialised model tag if present
  //
  QDomElement myAlgorithmElement = myTopElement.firstChildElement("Algorithm");
  QDomElement mySerialisedModelElement = myAlgorithmElement.firstChildElement("Model");
  if (!mySerialisedModelElement.isNull())
  {
    QDomDocument myModelDoc("MyModel");
    myModelDoc.appendChild(mySerialisedModelElement);
    //set the (optional) normalisation def after stripping off the doctype tag
    setModelDefinition(myModelDoc.toString().remove("<!DOCTYPE MyModel>"));
  }

  //
  // Extract the serialised normalisation parameters if present
  //
  QDomElement mySerialisedNormalizationElement = myAlgorithmElement.firstChildElement("Normalization");
  if (mySerialisedNormalizationElement.isNull())
  {
    qDebug("Normalisation element could not be found!");
    //do nothing (its optional
  }
  else
  {
    QDomDocument myModelDoc("MyNormalization");
    myModelDoc.appendChild(mySerialisedNormalizationElement);
    //set the mode def after stripping off the doctype tag
    setNormalizationDefinition(myModelDoc.toString().remove("<!DOCTYPE MyNormalization>"));
  }
  return true;
}

bool OmgModel::postProcess()
{
  if (QFile::exists(workDir() + rawImageFileName()))
  {
    appendToLog( tr("Processing model results for ") + taxonName() );
    //save a nice looking png of the image to disk
    OmgGdal myGdal;
    QFileInfo myFileInfo(rawImageFileName());
    //get the raw wild name but without its extension
    QString myBaseName=myFileInfo.baseName();
    QString myImageFileName = myBaseName+".png";
    //convert tif generated by om to pseudocolor png
    //qDebug("Calling omggdal::writeImage(" +  mypModel->rawImageFileName().toLocal8Bit() + ","
    //+ myImageFileName.toLocal8Bit()+")");
    //
    // Deprecated for now 
    //
    //myGdal.writeImage(mypModel->workDir() + mypModel->rawImageFileName(),
    //    mypModel->workDir() + myImageFileName);
    //mypModel->setColouredImageFileName(myImageFileName);
    //save the legend for this pseudocolour image
    QString myLegendName = myBaseName+"_legend.png";
    myGdal.makeLegend(workDir() + myLegendName, 600);
    setLegendFileName(myLegendName);
    // 
    // and a smaller version for this report
    // 
    QString myPreviewImageName = myBaseName+"_preview.png";
    myGdal.writeImage(workDir() + rawImageFileName(),
        workDir() + myPreviewImageName,
        600, //width
        400); //height
    setPreviewFileName(myPreviewImageName);
    //
    // Create ascii grid file - disabled as can result in rediculously
    // large files
    //
    //QString myAsciiFileName = myBaseName + ".asc";
    //if (!myGdal.gdal2Ascii(workDir() + rawImageFileName(),
    //      workDir() + myAsciiFileName))
    //{
    //  emit logMessage(tr("Failed to convert model raster to AsciiGrid"));
    //}

    //
    // Create a csv file of the samples
    //
    Omgui::createTextFile(workDir() + myBaseName + ".csv" , localitiesToCsv());
    setCsvFileName(myBaseName + ".csv");
    if (!QFile::exists(workDir() + rawImageFileName()))
    {
      appendToLog(tr("Model post processing failed"));
      setCompleted(false);
      setError(true);
      return false;
    }
    else
    {
      //now the model is done we can mark it as such
      appendToLog(tr("Model post processing successful"));           
      setCompleted(true);
      setError(false);
    }
  }
  else
  {
    appendToLog(tr("Model projection did not produce any output")); 
    setError(true);
    setCompleted(false);
    return false;
  }
  //set the end time
  setEndDateTimeStamp(QDateTime::currentDateTime());
  //
  // Create the thumbnail - the createThumbnail method
  // will gracefully handle aborted / not completed
  // models
  // 
  createThumbnail();
  //
  // Generate the model report in html format
  //
  toHtml(true);
  return true;
}

---