SystemProcessSave.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2016 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 SYSTEMPROCESSSAVE_HPP
#define SYSTEMPROCESSSAVE_HPP
 
#include <Process.hpp>
 
#include <QFileDialog>
#include <QRegExp>
#include <GraphUtils.hpp>
#include <QTreeWidget>
 
class QDialog;
class Ui_SaveMeshDialog;
class Ui_ExportMeshDialog;
class Ui_ExportStackDialog;
class Ui_PlyCellGraphDlg;
 
namespace mgx 
{
  
  class mgx_EXPORT StackSave : public Process {
  public:
    StackSave(const Process& proc) : Process(proc)
    {
      setName("Stack/System/Save");
      setDesc("Save a stack into a known 3D image format");
 
      addParm("Filename","Filename","");                        // 0
      addParm("Store","Store","Main", storeChoice());                           // 1
      addParm("Stack Number","Stack number","0");                               // 2
      addParm("Compression Level","Compression level, from 0 to 9","5");                        // 3
      addParm("HDF5 DataSetName","HDF5 DataSetName","/label");    // 4
    }
 
    bool initialize(QWidget* parent);
 
    bool run();
    bool run(Stack* stack, Store* store, const QString& filename, int compressionLevel = 0);
    QIcon icon() const { return QIcon(":/images/save.png"); }
  };
  
  class mgx_EXPORT StackExport : public Process {
    Q_OBJECT
  public:
    StackExport(const Process& proc) : Process(proc)
    {
      setName("Stack/System/Export");
      setDesc("Export a stack into an image sequence.");
 
      addParm("Filename","Filename","");                        // 0
      addParm("Store","Store","Main", storeChoice());                           // 1
      addParm("Format","Format","CImg Auto");                   // 2
      addParm("Generate Voxel Spacing","Generate Voxel Spacing","No", booleanChoice()); // 3
      addParm("Stack Number","Stack number","0");                               // 4
      addParm("Num Digits","Number of digits for file numbering","0");                          // 5
    }
 
    bool initialize(QWidget* parent);
 
    bool run();
    bool run(Stack* stack, Store* store, const QString& filename, const QString& type,
             unsigned int nb_digit, bool generate_voxel_spacing);
    QIcon icon() const { return QIcon(":/images/save.png"); }
 
  protected slots:
    void selectImageFile();
    void setImageType(const QString& type);
 
  protected:
    Ui_ExportStackDialog* ui;
    QDialog* dlg;
  };
  
  class mgx_EXPORT MeshSave : public Process {
    Q_OBJECT
  public:
    MeshSave(const Process& proc) : Process(proc)
    {
      setName("Mesh/System/Save");
      setDesc("Save a mesh into a known mesh format");
 
      addParm("Filename","Filename","");                        // 0
      addParm("Transform","Transform","No", booleanChoice());                   // 1
      addParm("Mesh Number","Mesh number","0", QStringList() << "0" << "1");                    // 2
    }
 
    bool run();
    bool run(Mesh* mesh, const QString& filename, bool transform);
    QIcon icon() const { return QIcon(":/images/save.png"); }
    bool initialize(QWidget* parent);
 
  protected slots:
    void selectMeshFile();
 
  protected:
    QString properFile(QString filename) const;
    void setMeshFile(const QString& filename);
    Point3d savedPos(Point3d pos, bool transform, const Stack* stack);
 
    bool saveMesh(Mesh* mesh, const QString& filename, bool transform);
 
    QDialog* dlg;
    Ui_SaveMeshDialog* ui;
  };
  
 
  bool savePLYCellGraph(Mesh* mesh, const QString& filename, bool binary);
 
  class mgx_EXPORT MeshExport : public Process {
    Q_OBJECT
  public:
    MeshExport(const Process& proc) : Process(proc)
    {
      setName("Mesh/System/Export");
      setDesc("Export a mesh into a known mesh format");
 
      addParm("Filename","Filename","");                        // 0
      addParm("Kind","Kind","Text", QStringList() << "PLY Binary" << "PLY Ascii" << "VTK Mesh Binary"
              << "VTK Mesh Ascii" << "Text" << "Cells" << "MeshEdit" << "STL" << "OBJ");                        // 1
      addParm("Transform","Transform","no", booleanChoice());                   // 2
      addParm("Mesh Number","Mesh number","0", booleanChoice());                                // 3
      addParm("Extended PLY","If the PLY format is chosen, save a mesh file with extended information","No", booleanChoice());    // 2
    }
 
    bool run();
    bool run(Mesh* mesh, const QString& filename, const QString& type, bool transform);
    QIcon icon() const { return QIcon(":/images/save.png"); }
    bool initialize(QWidget* parent);
 
    bool savePLY(Mesh* mesh, const QString& filename, bool transform, bool binary = false); // Soeren: made public to be accessible by new 2-file Ply process in HeatMap
 
  protected slots:
    void selectMeshFile();
    void selectMeshType(const QString& type);
 
  protected:
    QString properFile(QString filename, const QString& type) const;
    void setMeshFile(const QString& filename);
    Point3d savedPos(Point3d pos, bool transform, const Stack* stack);
 
    bool saveText(Mesh* mesh, const QString& filename, bool transform);
    bool saveCells(Mesh* mesh, const QString& filename, bool transform);
    bool saveMeshEdit(Mesh* mesh, const QString& filename, bool transform);
    bool saveMeshSTL(Mesh* mesh, const QString& filename, bool transform);
    bool saveVTU(Mesh* mesh, const QString& filename, bool transform, bool binary = false);
    bool saveOBJ(Mesh* mesh, const QString& filename, bool transform);
 
    QDialog* dlg;
    Ui_ExportMeshDialog* ui;
 
    bool extendedPLY = false;
  };
  
  class mgx_EXPORT SaveViewFile : public Process {
  public:
    SaveViewFile(const Process& proc) : Process(proc)
    {
      setName("Misc/System/Save View");
      setDesc("Save the view file for the current configuration.");
 
      addParm("Filename","Filename","");                        // 0
    }
 
    bool run();
    bool run(const QString& filename);
 
    bool initialize(QWidget* parent);
 
    QIcon icon() const { return QIcon(":/images/save.png"); }
  };
  
  class mgx_EXPORT QuickSaveFile : public Process {
  public:
    QuickSaveFile(const Process& proc) : Process(proc)
    {
      setName("Misc/System/Quick Save");
      setDesc("Save all active mesh, stack and view files.");
 
      addParm("Save with File Extensions","Save with File Extensions","No", booleanChoice());                   // 0
      addParm("Extension Counter","Extension Counter","1");                     // 1
    }
 
    void saveStore(int stackNr, Store* store, int compressionLevel);
    void saveMesh(int meshNr);
 
    QString addIncSuffix(QString filename, QString fileExtension);
 
    bool saveWithExt;
    int extCounter;
 
    bool initialize(QWidget* parent);
 
    bool run();
 
    QIcon icon() const { return QIcon(":/images/save.png"); }
  };
 
  class mgx_EXPORT TakeSnapshot : public Process {
  public:
    TakeSnapshot(const Process& proc) : Process(proc)
    {
      setName("Misc/System/Snapshot");
      setDesc("Take a snapshot of the current view");
 
      addParm("Filename","Filename","");                        // 0
      addParm("Expand Frustum","Expand Frustum","false");                       // 1
      addParm("Width","Width","0");                             // 2
      addParm("Height","Height","0");                           // 3
      addParm("Oversampling","Oversampling","1.0");                             // 4
      addParm("Quality","Quality","95");                        // 5
    }
 
    bool run()
    {
      QString filename = parm("Filename");
      if(filename.isEmpty())
        return setErrorMessage("Error, no file name specified.");
      int width = parm("Width").toInt();
      int height = parm("Height").toInt();
      float overSampling = parm("Oversampling").toFloat();
      int quality = parm("Quality").toInt();
      bool expand_frustum = stringToBool(parm("Expand Frustum"));
      return run(filename, overSampling, width, height, quality, expand_frustum);
    }
 
    bool run(QString filename, float overSampling, int width, int height, int quality, bool expand_frustum);
 
    QIcon icon() const { return QIcon(":/images/SaveScreenshot.png"); }
  };
 
 
  class mgx_EXPORT StackOpenSaveFolder : public Process {
  public:
    StackOpenSaveFolder(const Process& proc) : Process(proc)
    {
      setName("Stack/System/Batch Open and Save");
      setDesc("Opens and saves a compressed TIFF for all tif stacks of a folder");
 
      addParm("Folder","Folder","");                            // 0
      addParm("File Prefix","File Prefix for new files","MGX_");                                // 1
      addParm("Compression Level","Compression Level (-1 to 9)","9");                           // 2
    }
  
    bool run();
 
    QStringList images;
 
    bool initialize(QWidget* parent);
    QIcon icon() const { return QIcon(":/images/open.png"); }
  };
 
  class CellGraph3D : public Process
  {
  public:
    CellGraph3D(const Process& process) : Process(process) 
    {
      setName("Mesh/Export/Cell Graph 3D");
      setDesc("Export the 3D cell graph");
      setIcon(QIcon(":/images/CellGraph3D.png"));
    
      addParm("File Name", "File name to save cell graph","CellGraph3D.csv");
      addParm("Min Area", "Minimum area of cell-cell interfaces to include in CSV file, 0 for all", "0.0");
      addParm("Tolerance", "Tolerance for collapsing shared vertices", "0.0001");
    }
 
    bool run()
    {
        if(!checkState().mesh(MESH_NON_EMPTY))
          return false;
 
        Mesh *m = currentMesh();
        bool res = run(m, parm("File Name"), parm("Min Area").toDouble(), parm("Tolerance").toDouble());
        if(res)
          m->showHeat();
        return res;
    }
 
    bool run(Mesh* mesh, const QString &fileName, double minArea, double tolerance);
  };
}
 
#endif