Process.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef PROCESS_HPP
#define PROCESS_HPP
 
#include <Config.hpp>
#include <GL.hpp>
 
#include <QIcon>
#include <QSharedPointer>
#include <QStringList>
#include <QTextStream>
 
#include <MGXCamera.hpp>
#include <ProcessParms.hpp>
#include <Forall.hpp>
#include <Vector.hpp>
#include <Attributes.hpp>
#include <Information.hpp>
#include <Clip.hpp>
#include <CuttingSurface.hpp>
#include <Mesh.hpp>
#include <Stack.hpp>
#include <Store.hpp>
 
#include <algorithm>
#include <iostream>
#include <typeinfo>
#include <tr1/memory>
 
class QWidget;
class MorphoGraphX;
 
#define PROCESS_VERSION 1380
 
namespace mgx 
{
  #ifndef DOXYGEN
  enum SystemCommand { UPDATE_VIEWER, LOAD_VIEW, SAVE_VIEW, SET_CURRENT_STACK,
                       TAKE_SNAPSHOT, UPDATE_STATE, SET_STATUS };
 
  class PrivateProcess;
  class SetupProcess;
  #endif
  
  class mgx_EXPORT UserCancelException : public std::exception {
  public:
    UserCancelException() : std::exception() {}
  
    const char* what() const throw() {
      return "Process canceled by user.";
    }
  };
  
  class mgx_EXPORT Process : public QObject, public virtual ProcessParms
  {
    Q_OBJECT
    friend class SetupProcess;
  public:
    static unsigned int processVersion;
  
    typedef std::vector<Stack*>::iterator stack_iterator;
    typedef std::vector<Stack*>::const_iterator const_stack_iterator;
  
    typedef std::vector<Mesh*>::iterator mesh_iterator;
    typedef std::vector<Mesh*>::const_iterator const_mesh_iterator;
 
  private:
    Process();
  public:
    Process(const Process& p);
  public:
    virtual ~Process() {}
  
    void actingFile(const QString& filename, bool project_file = false);
  
    QString actingFile() const;
  
    QString pythonCall(const QStringList &parms) const;
  
    int stackCount() const;
    Stack* stack(int i);
    Stack* currentStack();
    Stack* otherStack();
    int currentStackId() const;
    int otherStackId() const;
    void setCurrentStackId(int i);
    bool setCurrentStack(int id, const QString &store);
  
    //bool resetProject();
  
    bool takeSnapshot(QString filename, float overSampling = 1.0f, int width = 0, int height = 0, int quality = 95,
                      bool expand_frustum = false);
    bool setStatus(const QString &msg, bool alsoPrint = true);
 
    bool systemCommand(int command, const QStringList &parms);
 
    MGXCamera *camera();
 
    //
    std::pair<stack_iterator, stack_iterator> stacks();
    std::pair<const_stack_iterator, const_stack_iterator> stacks() const;
  
    Stack* addStack();
  
    bool deleteStack(int i);
  
    int meshCount() const;
    Mesh* mesh(int i);
    Mesh* currentMesh();
    Mesh* otherMesh();
    int currentMeshId() const;
    int otherMeshId() const;
    void setCurrentMeshId(int i);
  
    std::pair<mesh_iterator, mesh_iterator> meshes();
    std::pair<const_mesh_iterator, const_mesh_iterator> meshes() const;
  
    Mesh* addMesh(const Stack* stack);
  
    bool deleteMesh(int i);
  
    int selectedLabel() const;
  
    void setSelectedLabel(int label);
  
    float globalBrightness();
  
    float globalContrast();
  
    void setGlobalBrightness(float value);
  
    void setGlobalContrast(float value);
  
    bool meshSelection() const;
    bool lineBorderSelection() const;
  
    bool updateState();
    bool updateViewer();
    bool loadView(const QString &fileName);
    bool saveView(const QString &fileName); 
 
    bool setErrorMessage(const QString& str);
  
    QString errorMessage() const;
  
    void setWarningMessage(const QString& str);
    QString warningMessage() const;
  
    void userCancel() const { throw UserCancelException(); }
  
    const QString& file() const;
  
    Clip *clip1();
    Clip *clip2();
    Clip *clip3();
  
    const Clip *clip1() const;
    const Clip *clip2() const;
    const Clip *clip3() const;
  
    CuttingSurface *cuttingSurface();
 
    const CuttingSurface *cuttingSurface() const;
  
    //\name Methods needed to launch other processes
  
    Process *makeProcess(const QString &processName);
 
    template <typename ProcessT>
    bool getProcess(const QString &processName, ProcessT* &p)
    {
      p = dynamic_cast<ProcessT*>(makeProcess(processName));
      if(p)
        return true;
      else
        return false;
    }
 
    bool setCurrentParms();
 
    enum ProcessAction { PROCESS_RUN, PROCESS_STEP, PROCESS_REWIND } ;
 
    bool runProcess(Process &proc, QStringList &parms) throw();
  
    bool runProcess(const QString &processName, QStringList &parms) throw();
 
  
    // @{ Functions to be defined by the user
 
    virtual bool initialize(QWidget * /*parent*/) { return true; }
 
    virtual bool run() { return true; }
 
    virtual bool finalize(QWidget * /*parent*/) { return true; }
 
    // @}
  
    static std::vector<Colorf> &LabelColors;
 
    //
    //\name Methods to get and check elements
  
    enum StackCheckType {
      STACK_ANY = 0,              
      STACK_NON_EMPTY = 0x01,     
      STACK_VISIBLE = 0x02,       
      STACK_EMPTY = 0x04,         
  
      STACK_SCALED = 0x08,              
      STACK_TRANSFORMED = 0x10,         
      STACK_NON_SCALED = 0x20,          
      STACK_NON_TRANSFORMED = 0x40,     
    };
  
    enum StoreCheckType {
      STORE_ANY = 0,                
      STORE_NON_EMPTY = 0x0001,     
      STORE_VISIBLE = 0x0002,       
      STORE_EMPTY = 0x0004,         
  
      STORE_LABEL = 0x0008,         
      STORE_NON_LABEL = 0x0010,     
  
      STORE_SCALED = 0x0020,              
      STORE_TRANSFORMED = 0x0040,         
      STORE_NON_SCALED = 0x0080,          
      STORE_NON_TRANSFORMED = 0x0100,     
  
      STORE_WORK = 0x1000,     
      STORE_MAIN = 0x2000      
    };
  
    enum MeshCheckType {
      MESH_ANY = 0,                  
      MESH_NON_EMPTY = 0x000001,     
      MESH_VISIBLE = 0x000002,       
  
      MESH_HEAT = 0x000004,       
      MESH_LABEL = 0x000008,      
      MESH_NORMAL = 0x000010,     
  
      MESH_SIGNAL = 0x000020,      
      MESH_TEXTURE = 0x000040,     
      MESH_IMAGE = 0x000080,       
  
      MESH_SHOW_MESH = 0x000100,     
      MESH_SHOW_SURF = 0x000200,     
  
      MESH_ALL = 0x000400,         
      MESH_BORDER = 0x000800,      
      MESH_CELLMAP = 0x001000,     
  
      MESH_CELLS = 0x002000,           
      MESH_IMG_TEX = 0x004000,         
      MESH_SCALED = 0x008000,          
      MESH_TRANSFORMED = 0x010000,     
  
      MESH_EMPTY = 0x020000,               
      MESH_NON_CELLS = 0x040000,           
      MESH_NON_IMG_TEX = 0x080000,         
      MESH_NON_SCALED = 0x100000,          
      MESH_NON_TRANSFORMED = 0x200000,     
 
      MESH_USE_PARENTS = 0x400000,         
    };
  
    enum CheckType {
      CHECK_STACK = 0,     
      CHECK_STORE = 1,     
      CHECK_MESH = 2       
    };
  
    enum CheckWhich {
      CHECK_CURRENT = -1     
    };
  
    class mgx_EXPORT CheckState {
  public:
      CheckState(const CheckState& copy);
      CheckState(Process* process);
  
      CheckState& store(int checks = STORE_ANY, int which = CHECK_CURRENT);
      CheckState& stack(int checks = STACK_ANY, int which = CHECK_CURRENT);
      CheckState& mesh(int checks = MESH_ANY, int which = CHECK_CURRENT);
  
      operator bool();
  
  protected:
      void setError();
  
      struct ProcessReqs {
        int type;
        int checks;
        int which;
      };
  
      QList<ProcessReqs> reqs;
      Process* process;
    };
  
    friend class Process::CheckState;
  
    CheckState checkState();
  
    PrivateProcess* p;
  
  protected:
  
    bool stackCheck(int checks, int which);
    bool storeCheck(int checks, int which);
    bool meshCheck(int checks, int which);
  
    QString stackError(int checks, int which);
    QString storeError(int checks, int which);
    QString meshError(int checks, int which);
  signals:
    void systemCommandGui(mgx::Process *, int, QStringList);
    void systemCommandProcess(mgx::Process *, int, QStringList);
  };
  
  #ifndef DOXYGEN
  
  //struct ProcessFactory 
  struct mgx_EXPORT ProcessFactory 
  {
    ProcessFactory() {}
    virtual ~ProcessFactory() {}
  
    virtual Process* operator()(const Process& process) = 0;
    virtual void reload() = 0;
  };
  
  //#  ifdef WIN32
  //struct mgx_EXPORT ProcessFactory;
  //#  endif
  
  template<typename ProcessName> struct ClassProcessFactory : public ProcessFactory 
  {
    ClassProcessFactory() : ProcessFactory(), pPtr(0) {}
  
    virtual Process* operator()(const Process& process) 
    {
      // Recycle the process object to allows variable persistence
      if(!pPtr)
        pPtr = new ProcessName(process);
      return pPtr;
    }
    void reload() 
    {
      // Recycle the process object to allows variable persistence
      if(pPtr) {
        delete pPtr;
        pPtr = 0;
      }
    }
    virtual ~ClassProcessFactory() 
    {
      if(pPtr)
        delete pPtr;
    }
 
    ProcessName *pPtr;
  };
  
  // Smart pointer to factory
  typedef std::tr1::shared_ptr<ProcessFactory> ProcessFactoryPtr;
  
  struct mgx_EXPORT Registration {
    typedef QList<ProcessFactoryPtr> factoryList;
  
    Registration(ProcessFactoryPtr f, const char* class_name, unsigned int compiledVersion);
    ~Registration();
    static factoryList& processFactories();
  
    ProcessFactoryPtr factory;
    const char* classname;
  };
  
  inline QList<ProcessFactoryPtr>& processFactories() 
  {
    return Registration::processFactories();
  }
  #endif
  
  #define REGISTER_PROCESS(ClassName) \
            mgx::Registration ClassName ## registration( \
            mgx::ProcessFactoryPtr(new mgx::ClassProcessFactory<ClassName>()), \
                                     typeid(ClassName).name(), PROCESS_VERSION)
 
  struct mgx_EXPORT ProcessDefinition 
  {
    QString name;            
    QString description;     
    QStringList parmNames;   
    QStringList parmDescs;   
    QStringList parms;       
    QIcon icon;              
    ParmChoiceList parmChoice;   
 
    typedef Process process_t;
    ProcessFactoryPtr factory;
  };
  
  #ifndef DOXYGEN
    typedef QMap<QString, ProcessDefinition> processesMap_t;
    
    mgx_EXPORT extern processesMap_t processes;
  #endif
  
 
  mgx_EXPORT ProcessDefinition* getProcessDefinition(const QString& processName);
  
  mgx_EXPORT bool getLastParms(const Process& proc, QStringList& parms);
  mgx_EXPORT bool getDefaultParms(const Process& proc, QStringList& parms);
  mgx_EXPORT bool saveDefaultParms(const Process& proc, const QStringList &parms);
  mgx_EXPORT bool checkProcessParms(const Process& proc, const QStringList &parms, size_t* nbParms = 0);
  mgx_EXPORT bool getLastParms(const QString& processName, QStringList& parms);
  mgx_EXPORT bool getDefaultParms(const QString& processName, QStringList& parms);
  mgx_EXPORT bool saveDefaultParms(const QString& processName, const QStringList &parms);
  mgx_EXPORT bool checkProcessParms(const QString& processName, const QStringList &parms,
                                    size_t* nbParms = 0);
  mgx_EXPORT ProcessDefinition* getProcessDefinition(const QString& processThread, const QString& processName);
  mgx_EXPORT QStringList listProcesses();
  mgx_EXPORT bool getProcessText(const QString &text, QString &tab, QString &folder, QString &name);
 
  mgx_EXPORT bool validProcessName(const QString& processName);
  
  mgx_EXPORT bool stringToBool(const QString& string);
  mgx_EXPORT bool stringToWorkStore(const QString& string);
  mgx_EXPORT bool stringToMainStore(const QString& string);
  
  inline QString boolToString(bool b) { return (b ? "Yes" : "No"); }
  
}
#endif