omgmodellerlocalplugin.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 "omgmodellerlocalplugin.h"
#include "omgalgorithm.h"
#include "omgomlogcallback.h"
#include "omgui.h" //ancilliary helper methods
#include <omggdal.h>
//qt includes
#include <QStringList>
#include <QFile>
#include <QDir>
#include <QDomDocument>
#include <QDomElement>
#include <QDomText>
#include <QTimer>
//needed for Q_EXPORT_PLUGIN macro at the end of this file
#include <QtPlugin>


//om includes
#include <openmodeller/om.hh>
#include <openmodeller/Configuration.hh>
#include <openmodeller/Exceptions.hh>

//
//Standard includes
#include <istream>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>  // I/O 
#include <fstream>   // file I/O
#include <sstream>     // treat string as a stream
#include <string>

#include <stdexcept>

//
// A global variable needed to set up the call back for loggin from openModeller
//
QTextStream* output;
bool OmgModellerLocalPlugin::mAlgFactoryStartedFlag=false;

OmgModellerLocalPlugin::OmgModellerLocalPlugin( QObject * parent) : 
      QObject (parent),
      OmgModellerPluginInterface(), 
      mpOpenModeller(new OpenModeller()),
      mpLogCallBack (new OmgOmLogCallback(*(output)))
{
  qDebug("Creating modeller local plugin");
  initialise();
}

OmgModellerLocalPlugin::~OmgModellerLocalPlugin()
{
    disconnect (mpLogCallBack);
    g_log.setCallback( 0 );
    delete mpOpenModeller;
    qDebug("Destroying modeller local plugin");
}

bool OmgModellerLocalPlugin::initialise()
{
  qDebug(tr("-------Modeller Plugin Initialising---------").toLocal8Bit());
  // Note this function searches for om plugins - and should only
  // ever be run once in the life of the openModeller desktop application session
  //
  if (!OmgModellerLocalPlugin::mAlgFactoryStartedFlag)
  {
    qDebug("Initialising openmodeller local plugin...calling AlgorithmFactory::searchDefaultDirs()");
    AlgorithmFactory::searchDefaultDirs();
    OmgModellerLocalPlugin::mAlgFactoryStartedFlag=true;
  }
  else
  {
    qDebug("Initialising openmodeller local plugin...NOT calling AlgorithmFactory::searchDefaultDirs()");
    //do nothing
  }
  //set up callbacks
  g_log.setLevel( Log::Debug );
  g_log.setCallback(mpLogCallBack );

  //connect up our messenger class which delegates signals
  //since a plugin in Qt cannot directly inherit from qobject
  connect(mpLogCallBack, SIGNAL(omLogMessage(QString,QString)),
      &mMessenger, SLOT(emitModelMessage(QString,QString)));
  connect(mpLogCallBack, SIGNAL(omLogError(QString,QString)),
      &mMessenger, SLOT(emitModelError(QString,QString)));
  //connect to this class's logger too so we can insert logs into OmgModel
  //when create and project are called
  connect(mpLogCallBack, SIGNAL(omLogMessage(QString,QString)),
      this, SLOT(appendToLog(QString,QString)));
  connect(mpLogCallBack, SIGNAL(omLogError(QString,QString)),
      this, SLOT(appendToLog(QString,QString)));
  mpOpenModeller->setModelCallback( modelCallback, this );
  mpOpenModeller->setMapCallback( mapCallback, this );
  return true;

}

QString OmgModellerLocalPlugin::createModel(OmgModel * thepModel)
{
  thepModel->setError(false);
  mModelLog="";
  QString myModelResult;
  QString myFileName = thepModel->taxonName();
  mModelGuid = thepModel->guid();
  mpLogCallBack->setModelGuid(thepModel->guid());
  myFileName = myFileName.replace(" ","_");
  mMessenger.emitModelMessage(mModelGuid,tr("Running model for : ") + myFileName.toLocal8Bit());
  //get the file path in the format of the host OS as we will be passing this
  //over to om which wont automatically convert (qt classes do)
  QString myWorkDir = QDir::convertSeparators(thepModel->workDir());
  //std::string myFileNameString(myFileName.toLocal8Bit());
  // now use the local om lib to run the model
  try 
  {
    std::ostringstream myOutputStream ;
    QString myModelXml = thepModel->toModelCreationXml().trimmed();
    //for local models we need to append the modelparameters outer tag
    myModelXml = "<ModelParameters>\n"+ myModelXml + "\n</ModelParameters>";
    //first write the model xml to a file - this is just for user reference / debugging
    if (!Omgui::createTextFile(myWorkDir + myFileName+"_create.xml",myModelXml))
    {
      QString myWarning(tr("Unable to open ") + myFileName.toLocal8Bit() + tr(" for writing!"));
      mMessenger.emitModelError(mModelGuid,myWarning);
    }
    std::string myXml(myModelXml.toLocal8Bit().data());
    std::istringstream myStream;
    myStream.str(myXml);
    ConfigurationPtr c = Configuration::readXml( myStream );
    mpOpenModeller->setModelConfiguration(c);
    mpOpenModeller->createModel();
    ConfigurationPtr myConfiguration = mpOpenModeller->getModelConfiguration();
    Configuration::writeXml( myConfiguration, myOutputStream);
    mMessenger.emitModelDone(mModelGuid);
    myModelResult=QString::fromStdString(myOutputStream.str());
    //qDebug( myModelResult.toLocal8Bit());
    mModelProgress=0;
    mMessenger.emitModelCreationProgress(mModelGuid,100);
    thepModel->setLog(mModelLog);
    return myModelResult;
  }
  catch( std::exception& e ) 
  {
    mMessenger.emitModelError(mModelGuid,tr("Exception caught!\n"));
    mMessenger.emitModelError(mModelGuid,QString::fromStdString(e.what()));
    thepModel->setLog(mModelLog);
    thepModel->setError(true);
    return QString("");
  }
}

void  OmgModellerLocalPlugin::projectModel(OmgModel * thepModel)
{
  mModelLog="";
  QString myFileName = thepModel->taxonName();
  mModelGuid = thepModel->guid();
  mpLogCallBack->setModelGuid(thepModel->guid());
  myFileName = myFileName.replace(" ","_");
  mMessenger.emitModelMessage(mModelGuid,tr("Projecting model for : ") + myFileName.toLocal8Bit());
  //get the file path in the format of the host OS as we will be passing this
  //over to om which wont automatically convert (qt classes do)
  QString myWorkDir = QDir::convertSeparators(thepModel->workDir());
  //std::string myFileNameString(myFileName.toLocal8Bit());
  // now use the local om lib to run the model
  try 
  {
    std::ostringstream myOutputStream ;
    QString myModelXml = thepModel->toModelProjectionXml().trimmed();
    //for local models we need to append the modelparameters outer tag
    myModelXml = "<ProjectionParameters xmlns=\"http://openmodeller.cria.org.br/xml/1.0\">\n"
      + myModelXml + "\n</ProjectionParameters>";
    //first write the model xml to a file - this is just for user reference / debugging
    if (!Omgui::createTextFile(myWorkDir + myFileName+"_project.xml",myModelXml))
    {
      QString myWarning(tr("Unable to open ") + myFileName.toLocal8Bit() + tr(" for writing!"));
      mMessenger.emitModelError(mModelGuid,myWarning);
    }
    std::string myXml(myModelXml.toLocal8Bit().data());
    std::istringstream myModelStream;
    myModelStream.str(myXml);
    ConfigurationPtr mypConfiguration = Configuration::readXml( myModelStream );
    mpOpenModeller->setProjectionConfiguration(mypConfiguration);
    //this next line seems counterintuitive but its needed for deserialisation before projection
    mpOpenModeller->createModel();
    //cout << "Loading Projection Environment " << theEnvironment << endl;
    std::string myEnvironmentXml = thepModel->projectionLayersXml().toLocal8Bit().data();
    std::istringstream myEnvironmentStream;
    myEnvironmentStream.str(myEnvironmentXml);
    mypConfiguration =  Configuration::readXml( myEnvironmentStream );
    EnvironmentPtr mypEnvironment = createEnvironment( mypConfiguration );
    //cout << "Projecting to file " << theOutput << endl;
    QString myRawImageFileName =  myWorkDir + myFileName+"_projection."  + Omgui::getOutputFormatExtension();
    mpOpenModeller->createMap( mypEnvironment, myRawImageFileName.toLocal8Bit().data() );
    //store the model image file name in the model object
    thepModel->setRawImageFileName(myRawImageFileName);

    //ConfusionMatrix matrix;
    ConfusionMatrix * mypMatrix = mpOpenModeller->getConfusionMatrix();

    AreaStats * mypStats = mpOpenModeller->getActualAreaStats();
    QString myStatsString = tr("\nModel statistics\n" );
    myStatsString +=tr("Accuracy                              : ") 
      + QString::number( mypMatrix->getAccuracy() * 100 )
      + QString("%\n");
    myStatsString +=tr("Omission error                        : ") 
      + QString::number( mypMatrix->getOmissionError() * 100 )
      + QString("%\n");
    //why was this commented out in om_console?
    //myStatsString += QString( "Commission error:  %7.2f\%\n", matrix.getCommissionError() * 100 );
    myStatsString +=tr("Percentage of cells predicted present : ") 
      + QString::number (
          mypStats->getAreaPredictedPresent() / (double) mypStats->getTotalArea() * 100)
      + QString("%\n");
    myStatsString +=tr("Total number of cells                 : ")
      + QString::number( mypStats->getTotalArea() )
      + QString("\n");

    delete mypMatrix;
    delete mypStats;
    mMessenger.emitModelMessage(mModelGuid,myStatsString);
    thepModel->setModelStats(myStatsString);
    mModelProgress=0;
    mMessenger.emitModelProjectionProgress(mModelGuid,100);
    thepModel->appendToLog(mModelLog);
  }
  catch( std::exception& e ) 
  {
    mMessenger.emitModelError(mModelGuid,tr("Exception caught!\n"));
    mMessenger.emitModelError(mModelGuid,QString::fromStdString(e.what()));
    thepModel->appendToLog(mModelLog);
    thepModel->setError(true);
    return;
  }
}

const QStringList OmgModellerLocalPlugin::getAlgorithmList()
{ 
  qDebug("OmgModellerLocalPlugin::getAlgorithmList() called");
  const AlgMetadata **mypAlgorithmMetadataArray = mpOpenModeller->availableAlgorithms();
  const AlgMetadata *mypAlgorithmMetadata = *mypAlgorithmMetadataArray;
  QStringList myAlgList;

  while ( mypAlgorithmMetadata  )
  {
    myAlgList.append(mypAlgorithmMetadata->name);
    *mypAlgorithmMetadataArray++;
    mypAlgorithmMetadata = *mypAlgorithmMetadataArray;
  }
  myAlgList.sort();
  return myAlgList;
}

const OmgAlgorithmSet OmgModellerLocalPlugin::getAlgorithmSet()
{
  const AlgMetadata **mypAlgorithmMetadataArray = mpOpenModeller->availableAlgorithms();
  const AlgMetadata *mypAlgorithmMetadata = *mypAlgorithmMetadataArray;

  OmgAlgorithmSet myAlgorithmSet;
  myAlgorithmSet.setName("Local Plugin Algorithms");
  myAlgorithmSet.setDescription("These are the algorithms available on your local machine ");
  
  while ( mypAlgorithmMetadata  )
  {
    QString myName(mypAlgorithmMetadata->name);
    QString myId(mypAlgorithmMetadata->id);
    OmgAlgorithm myAlgorithm = getAlgorithm(myId);
    myAlgorithmSet.addAlgorithm(myAlgorithm);
    *mypAlgorithmMetadataArray++;
    mypAlgorithmMetadata = *mypAlgorithmMetadataArray;
  }
  return myAlgorithmSet; 
}

const OmgAlgorithm OmgModellerLocalPlugin::getAlgorithm( QString theId )
{       
  const AlgMetadata **mypAlgorithmMetadataArray = mpOpenModeller->availableAlgorithms();
  const AlgMetadata *mypAlgorithmMetadata = *mypAlgorithmMetadataArray;

  while ( mypAlgorithmMetadata  )
  {
    QString myId(mypAlgorithmMetadata->id);
    if (myId==theId)
    {
      OmgAlgorithm myAlgorithm;
      myAlgorithm.setId( QString( mypAlgorithmMetadata->id ));
      myAlgorithm.setName( QString(  mypAlgorithmMetadata->name ));
      myAlgorithm.setVersion(  QString( mypAlgorithmMetadata->version));
      myAlgorithm.setGuid();
      myAlgorithm.setCategorical(  mypAlgorithmMetadata->categorical);
      myAlgorithm.setAbsence( mypAlgorithmMetadata->absence);
      myAlgorithm.setAuthor(  QString( mypAlgorithmMetadata->author));
      myAlgorithm.setCodeAuthor(  QString( mypAlgorithmMetadata->code_author));
      myAlgorithm.setContact(  QString( mypAlgorithmMetadata->contact));
      myAlgorithm.setOverview(  QString( mypAlgorithmMetadata->overview));
      myAlgorithm.setDescription(  QString( mypAlgorithmMetadata->description));
      myAlgorithm.setBibliography(  QString( mypAlgorithmMetadata->biblio));

      //qDebug ("getting algorithm parameters from metadata");
      int myParameterCountInt = mypAlgorithmMetadata->nparam;
      AlgParamMetadata * myParameter = mypAlgorithmMetadata->param;
      //interate through parameters adding the correct control type
      for ( int i = 0; i < myParameterCountInt; i++, myParameter++ )
      {
        //qDebug("Getting next parameter");
        OmgAlgorithmParameter myOmgParameter;

        //  moment thats because is is. In a future cleanup Il deal with real nos etc.

        myOmgParameter.setType( QString (myParameter->type ));
        myOmgParameter.setName( QString (myParameter->name ));
        myOmgParameter.setId( QString (myParameter->id ));
        if (!myParameter->has_min==0)
        {
          myOmgParameter.setMinimum( QString::number (myParameter->min_val ));
        }
        else
        {
          myOmgParameter.setMinimum( QString::number(INT_MIN) );
        }
        if (!myParameter->has_max==0)
        {
          myOmgParameter.setMaximum( QString::number (myParameter->max_val ));
        }
        else
        {
          myOmgParameter.setMaximum( QString::number(INT_MAX ));
        }
        myOmgParameter.setDefault(QString ( myParameter->typical ));
        myOmgParameter.setOverview(QString ( myParameter->overview ));
        myOmgParameter.setDescription(QString ( myParameter->description ));
        myAlgorithm.addParameter(myOmgParameter);
        //qDebug(myOmgParameter.toString().toLocal8Bit());
      }
      //define the origin of the algorithm - this is used by e.g. the algmanager
      //in the gui to differentiate between user profiles and profiles 
      //obtained from the plugin
      myAlgorithm.setOrigin(OmgAlgorithm::ADAPTERPROFILE);
      //Exit loop because we have found the correct algorithm
      return myAlgorithm;
    }
    *mypAlgorithmMetadataArray++;
    mypAlgorithmMetadata = *mypAlgorithmMetadataArray;
  }
  //not found
  qDebug("Algorithm not found for id"+theId.toLocal8Bit());
  return OmgAlgorithm();
}//getAlgorithm( QString theId )

void OmgModellerLocalPlugin::setCreationProgress (int theProgress)
{
  //qDebug("setCreationProgress: " + mModelGuid.toLocal8Bit() + " " + QString::number(theProgress).toLocal8Bit());
  if (mModelProgress != theProgress)
  {
    mModelProgress=theProgress;
    mMessenger.emitModelCreationProgress(mModelGuid,theProgress);
  }
}
void OmgModellerLocalPlugin::setProjectionProgress (int theProgress)
{
  //qDebug("setProjectionProgress: " + mModelGuid.toLocal8Bit() + " " +  QString::number(theProgress).toLocal8Bit());
  if (mModelProgress != theProgress)
  {
    mMapProgress=theProgress;
    mMessenger.emitModelProjectionProgress(mModelGuid,theProgress);
  }
}

void OmgModellerLocalPlugin::appendToLog( QString theGuid, QString theMessage)
{
  mModelLog += "\n" + theMessage;
}
 
const QString OmgModellerLocalPlugin::getLayers(QString theBaseDir)
{
  QTimer *mypTimer = new QTimer(this);
  connect(mypTimer, SIGNAL(timeout()), &mMessenger, SLOT(refresh()));
  mypTimer->start(1000);
  QString myLayers = Omgui::getLayers(theBaseDir);
  mypTimer->stop();
  delete mypTimer;
  return myLayers;
}


//
// non member callback functions
//
void modelCallback( float theProgress, void *thepPlugin )
{
 //cast the plugin to a local plugin
 //qDebug("modelCallBack: " + QString::number(theProgress).toLocal8Bit());
 OmgModellerLocalPlugin * mypPlugin = (OmgModellerLocalPlugin *) thepPlugin;
 mypPlugin->setCreationProgress(static_cast<int>(theProgress*100));
}
void mapCallback( float theProgress, void *thepPlugin )
{
 //qDebug("mapCallBack: " + QString::number(theProgress).toLocal8Bit());
 //cast the plugin to a local plugin
 OmgModellerLocalPlugin * mypPlugin = (OmgModellerLocalPlugin *) thepPlugin;
 mypPlugin->setProjectionProgress(static_cast<int>(theProgress*100));
}
    
// Entry point for the Qt plugin:
Q_EXPORT_PLUGIN2(local_modeller_plugin, OmgModellerLocalPlugin);

---