Mesh.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 MESH_HPP
#define MESH_HPP
 
#include <Config.hpp>
 
#include <Types.hpp>
#include <Attributes.hpp>
 
#include <cuda/CudaExport.hpp>
#include <CellTissue.hpp>
#include <Stack.hpp>
#include <TransferFunction.hpp>
 
#include <omp.h>
#include <QImage>
#include <string.h>
#include <typeinfo>
 
namespace mgx 
{
  typedef std::unordered_map<int, HVec3U> IntHVec3uMap;
  typedef std::pair<int, HVec3U> IntHVec3uPair;
 
  class SetupProcess;
  
  class mgx_EXPORT Mesh 
  {
    friend class SetupProcess;
  
  public:
    enum SurfView 
    {
      SURF_VERTEX,                                              
      SURF_LABEL,                                                               
      SURF_TRIANGLE,    
      SURF_VIEW_COUNT   
    };
  
    //Mesh(const Stack* stack);
  
    Mesh(int id, const Stack* stack);
  
    //Mesh(const Mesh &copy);
  
    ~Mesh();
  
  
    int id() const { return _id; }
  
    void setId(int i) { _id = i; }
  
    int userId() const { return _id + 1; }
 
    const Stack* stack() const { return _stack; }
 
    const QString &file() const { return _file; }
 
    void setFile(const QString &file = QString());
 
    bool scaled() const { return _scaled; }
 
    void setScaled(bool on = true) { _scaled = on; }
  
    bool transformed() const { return _transformed; }
 
    void setTransformed(bool on = true) { _transformed = on; }
  
    bool showBBox() const { return _showBBox; }
  
    void setShowBBox(bool on = true) { _showBBox = on; }
  
    int viewLabel() const { return T.viewLabel(); }
 
    void setLabel(int l) { T.setLabel(l); }
 
    int nextLabel() { return T.nextLabel(); }
 
  
 
    const Attributes &attributes() const
    {
      return _attributes;
    }
 
    Attributes &attributes()
    {
      return _attributes;
    }
 
    IntIntAttr &parents() 
    {
      return _attributes.attrMap<int, int>("Cell Parent");
    }
 
    const QString &meshType()
    {
      return T.meshType();
    }
 
    const QString &setMeshType(const QString &mType)
    {
      return T.setMeshType(mType);
    }
 
    bool mesh3D()
    {
      if(meshType() == "MGX3D")
        return true;
      return false;
    }
 
    IntPoint3fAttr &labelCenter() 
    {
      return _attributes.attrMap<int, Point3f>("Cell Center");
    }
 
    IntPoint3fAttr &labelNormal() 
    {
      return _attributes.attrMap<int, Point3f>("Cell Normal");
    }
 
    IntPoint3fAttr &labelCenterVis() 
    {
      return _attributes.attrMap<int, Point3f>("Cell CenterVis");
    }
 
    IntPoint3fAttr &labelNormalVis() 
    {
      return _attributes.attrMap<int, Point3f>("Cell NormalVis");
    }
  
    IntPoint3fAttr &parentCenter() 
    {
      return _attributes.attrMap<int, Point3f>("Parent Center");
    }
 
    IntPoint3fAttr &parentNormal() 
    {
      return _attributes.attrMap<int, Point3f>("Parent Normal");
    }
 
    IntPoint3fAttr &parentCenterVis() 
    {
      return _attributes.attrMap<int, Point3f>("Parent CenterVis");
    }
 
    IntPoint3fAttr &parentNormalVis() 
    {
      return _attributes.attrMap<int, Point3f>("Parent NormalVis");
    }
 
 
    VtxPoint2fAttr &texCoord2d()
    {
      return _attributes.attrMap<vertex, Point2f>("Vertex TexCoord2D");
    }
 
    void reset();
  
  
    vvGraph &graph() { return T.S; }
 
    const vvGraph &graph() const { return T.S; }
  
    vvGraph &junctions() { return T.J; }
 
    const vvGraph &junctions() const { return T.J; }
 
    const CellTissue &tissue() const { return T; }
 
    CellTissue &tissue() { return T; }
 
    cellGraph &cells() { return T.C; }
 
    const cellGraph &cells() const { return T.C; }
 
    bool empty() const { return T.S.empty() && T.C.empty(); }
 
    CellTissue::DistNhbdS &nhbdS() { return T.nhbdS; }
 
    CellTissue::DistNhbdC &nhbdC() { return T.nhbdC; }
 
    //size_t size() const { return T.S.size(); }
 
    int getLabel(const vertex &v1, const vertex &v2, const vertex &v3, 
                                           const IntIntAttr &parents);
    int getLabel(int label, const IntIntAttr &parents);
 
    bool chkGraph(vvGraph &S) { return T.chkGraph(S); }  
    bool chkGraph() { return T.chkGraph(T.S); }
 
    IntIntVIdSetMap &wallVId() { return _wallVId; }
 
    const IntIntVIdSetMap &wallVId() const { return _wallVId; }
 
    IntIntFloatAttr &wallGeom() 
    {
      return _attributes.attrMap<IntIntPair, float>("Wall Geom");
    }
 
    IntIntSetMap &labelNeighbors() { return _labelNeighbors; }
 
    const IntIntSetMap &labelNeighbors() const { return _labelNeighbors; }
  
    void updateWallGeometry(float borderSize);
 
    bool isBordTriangle(int label, vertex v, vertex n, vertex m, IntIntPair &rp) const;
  
    void markBorder(float borderSize);
  
    void updateCentersNormals();
  
  
 
    TransferFunction surfFct() const { return _surf_fct; }
 
    void setSurfFct(const TransferFunction &f)
    {
      if(_surf_fct != f) {
        _surf_fct = f;
        changed_surf_function = true;
      }
    }
    bool surfFctChanged() const { return changed_surf_function; }
  
    TransferFunction heatFct() const { return _heat_fct; }
 
    void setHeatFct(const TransferFunction &f)
    {
      if(_heat_fct != f) {
        _heat_fct = f;
        changed_heat_function = true;
      }
    }
    bool heatFctChanged() const { return changed_heat_function; }
  
    float opacity() const { return _opacity; }
 
    void setOpacity(float f)
    {
      if(f < 0)
        _opacity = 0;
      else if(f > 1)
        _opacity = 1;
      else
        _opacity = f;
    }
    float brightness() const { return _brightness; }
 
    void setBrightness(float f)
    {
      if(f < 0.0)
        _brightness = 0.0;
      else if(f > 1.0)
        _brightness = 1.0;
      else
        _brightness = f;
    }
  
    bool showSurface() const { return _showSurface; }
 
    void setShowSurface(bool val = true) { _showSurface = val; }
 
    void setShowVertex(const QString &s = "", bool setView = true) 
    { 
      if(setView)
        _surfView = SURF_VERTEX; 
      if(s != "")
        _surfVertexView = s;
    }
 
    void setShowTriangle(const QString &s = "", bool setView = true) 
    {  
      if(setView)
        _surfView = SURF_TRIANGLE; 
      if(s != "")
        _surfTriangleView = s; 
    }
 
    void setShowLabel(const QString &s = "", bool setView = true) 
    {
      if(setView)
        _surfView = SURF_LABEL;
      if(s != "")
        _surfLabelView = s;
    }
  
    bool culling() const { return _culling; }
 
    void setCulling(bool cul) { _culling = cul; }
  
    bool blending() const { return _blending; }
 
    void setBlending(bool b) { _blending = b; }
  
    SurfView surfView() const { return _surfView; }
 
    void setSurfView(SurfView view) { _surfView = view; }
 
    QString surfVertexView() const { return _surfVertexView; }
 
    QString surfTriangleView() const { return _surfTriangleView; }
 
    QString surfLabelView() const { return _surfLabelView; }
 
    bool showSignal() const { return showSurface() and surfView() == SURF_VERTEX and surfVertexView() == "Signal"; }
    bool showLabels() const { return showSurface() and surfView() == SURF_LABEL and surfLabelView() == "Label"; }
    bool showHeat() const { return showSurface() and surfView() == SURF_LABEL and surfLabelView() == "Label Heat"; }
    bool showWallHeat() const { return showSurface() and surfView() == SURF_LABEL and surfLabelView() == "Wall Heat"; }
    bool showTriangleValue() const { return showSurface() and surfView() == SURF_TRIANGLE and surfTriangleView() == "Triangle Value"; }
 
    bool useParents() { return _useParents; }
 
    void setUseParents(bool val) { _useParents = val; }
 
    bool &hasImgTex() 
    { 
      return _attributes.attrMap<QString, bool>("HasImageTex")["HasImageTex"];
    }
 
    const QImage &imgTex() const { return _image; }
    QImage &imgTex() { return _image; }
 
    void setImgTex(const QImage &img)
    {
      hasImgTex() = true;
      _image = img;
    }
 
    void clearImgTex()
    {
      _imgtex = false;
      _attributes.attrMap<QString, QByteArray>("ImageTex").erase("ImageTex");
      _image = QImage();
    }
  
  
 
    bool showMesh() const { return _showMesh; }
 
    QString meshView() const { return _meshView; }
 
    void setShowMesh(bool show = true) { _showMesh = show; }
 
    void setMeshView(const QString &s, bool setShow = true) 
    { 
      if(setShow)
        _showMesh = true; 
      _meshView = s;
    }
 
    bool showAxis() const { return _showAxis; }
 
    QString axisView() const { return _axisView; }
 
    void setShowAxis(bool show = true) { _showAxis = show; }
 
    void setAxisView(const QString &s, bool setShow = true) 
    { 
      if(setShow)
        _showAxis = true; 
      _axisView = s;
    }
 
    bool showMeshLines() const { return _showMeshLines; }
 
    bool showMeshPoints() const { return _showMeshPoints; }
 
    bool showMeshCellMap() const { return _showMeshCellMap; }
 
    void setShowMeshLines(bool show) { _showMeshLines = show; }
 
    void setShowMeshPoints(bool show) { _showMeshPoints = show; }
 
    void setShowMeshCellMap(bool show) { _showMeshCellMap = show; }
 
    std::vector<vertex> selectedVertices() const;
 
    int selectedCount() const;
 
    std::vector<vertex> activeVertices() const;
 
    // These next two should really be algorithms for the graph as they don't rely on
    // any Mesh variables.
    void getConnectedVertices(const vvGraph &S, vvGraph &vSet) const;
 
    int getConnectedRegions(const vvGraph &S, VVGraphVec &cellVId, VtxIntMap &vtxCell) const;
  
    static void getNhbd(const vvGraph &S, const vertex &v, float radius, VtxSet &nbs);
    bool clearSelection(); 
    void correctSelection(bool inclusive);
  
  
 
    void updateAll();
    void updateTriangles();
    void updateLines();
    void updatePositions();
    void updateSelection();
    int changes() const { return _changed; }
  
 
    IntFloatAttr &labelHeat() 
    {
      return _attributes.attrMap<int, float>("Cell Heat");
    }
 
    QString &heatMapUnit() 
    {
      return _attributes.attrMap<QString, QString>("Cell Heat Unit")["Cell Heat Unit"];
    }
 
    QString &heatMapScaling() 
    {
      return _attributes.attrMap<QString, QString>("Cell Heat Unit")["Cell Heat Scaling"];
    }
 
    Point2f &heatMapBounds() 
    {
      return _attributes.attrMap<QString, Point2f>("Cell Heat Bounds")["Cell Heat Bounds"];
    }
 
    Point2f calcHeatMapBounds();
 
    IntIntFloatAttr &wallHeat() 
    {
      return _attributes.attrMap<IntIntPair, float>("Wall Heat");
    }
 
    Point2f &wallHeatBounds() 
    {
      return _attributes.attrMap<QString, Point2f>("Wall Heat Bounds")["Wall Heat Bounds"];
    }
 
    QString &wallHeatUnit() 
    {
      return _attributes.attrMap<QString, QString>("Wall Heat Unit")["Wall Heat Unit"];
    }
  
 
    TriVec3ColorbAttr &triangleColor() 
    {
      return _attributes.attrMap<Triangle, Vec3Colorb>("Triangle Color");
    }
 
    TriIntAttr &triangleIndex() 
    {
      return _attributes.attrMap<Triangle, int>("Triangle Index");
    }
 
    TriFloatAttr &triangleValue() 
    {
      return _attributes.attrMap<Triangle, float>("Triangle Value");
    }
 
    ColorbVec &triangleValueColors()
    {
      return _attributes.attrMap<QString, ColorbVec>("Triangle Value Color Map")["Triangle Value Color Map"];
    }
 
    Point2f &triangleValueBounds()
    {
      AttrMap<QString, Point2f> &a = _attributes.attrMap<QString, Point2f>("Triangle Value Bounds");
      a.defaultVal() = Point2f(0,1);
      return a["Triangle Value Bounds"];
    }
 
    QString &triangleValueUnit() 
    {
      return _attributes.attrMap<QString, QString>("Triangle Value Unit")["Triangle Value Unit"];
    }
 
    ColorbVec &triangleIndexColors()
    {
      return _attributes.attrMap<QString, ColorbVec>("Triangle Index Color Map")["Triangle Index Color Map"];
    }
 
    CellVec2ColorbAttr &cellColor() 
    {
      return _attributes.attrMap<cell, Vec2Colorb>("Cell Color");
    }
  
    // Axis methods 
 
    bool setAxisColor(const Colorb &pos, const Colorb &neg, const SymmetricTensor &s, Vec3Colorb &color);
 
    /*
     * Returns the axis line width
     */
    float axisWidth() 
    {
      float width = _attributes.attrMap<QString, float>("Axis Width")["Axis Width"];
      if(width < 1.0)
        width = 1.0;
      return width;
    }
 
    /*
     * Set the axis line width
     */
    float setAxisWidth(float width) 
    {
      if(width < 1.0)
        width = 1.0;
      _attributes.attrMap<QString, float>("Axis Width")["Axis Width"] = width;
      return width;
    }
 
    /*
     * Returns the axis z-offset for drawing
     */
    float axisOffset() 
    {
      return _attributes.attrMap<QString, float>("Axis Offset")["Axis Offset"];
    }
 
    /*
     * Sets the axis z-offset for drawing
     */
    float setAxisOffset(float offset) 
    {
      _attributes.attrMap<QString, float>("Axis Offset")["Axis Offset"] = offset;
      return offset;
    }
  
 
    IntSymTensorAttr &cellAxis() 
    {
      return _attributes.attrMap<int, SymmetricTensor>("Cell Axis");
    }
  
    IntMatrix3fAttr &cellAxisVis() 
    {
      return _attributes.attrMap<int, Matrix3f>("Cell Axis Vis");
    }
 
    IntVec3ColorbAttr &cellAxisColor() 
    {
      return _attributes.attrMap<int, Vec3Colorb>("Cell Axis Color");
    } 
 
    bool setCellAxisColor(const Colorb &pos, const Colorb &neg);
 
    QString cellAxisType()
    {
      return _attributes.attrMap<QString, QString>("Axis Type")["Axis Type"];
    }
 
    QString setCellAxisType(const QString &s) 
    {
      _attributes.attrMap<QString, QString>("Axis Type")["Axis Type"] = s;
      return s;
    }
 
    QString cellAxisUnit()
    {
      return _attributes.attrMap<QString, QString>("Axis Unit")["Axis Unit"];
    }
 
    QString setCellAxisUnit(const QString &s) 
    {
      _attributes.attrMap<QString, QString>("Axis Unit")["Axis Unit"] = s;
      return s;
    }
 
    void clearCellAxis();
  
 
    TriSymTensorAttr &triangleAxis() 
    {
      return _attributes.attrMap<Triangle, SymmetricTensor>("Triangle Axis");
    } 
  
    TriMatrix3fAttr &triangleAxisVis() 
    {
      return _attributes.attrMap<Triangle, Matrix3f>("Triangle Axis Vis");
    }
 
    TriVec3ColorbAttr &triangleAxisColor() 
    {
      return _attributes.attrMap<Triangle, Vec3Colorb>("Triangle Axis Color");
    }
    bool setTriangleAxisColor(const Colorb &pos, const Colorb &neg);
 
 
                                typedef std::pair<vertex, SymmetricTensor> VtxSymTensorPair;
 
    VtxSymTensorAttr &vertexAxis() 
    {
      return _attributes.attrMap<vertex, SymmetricTensor>("Vertex Axis");
    } 
  
    VtxMatrix3fAttr &vertexAxisVis() 
    {
      return _attributes.attrMap<vertex, Matrix3f>("Vertex Axis Vis");
    }
 
    VtxVec3ColorbAttr &vertexAxisColor() 
    {
      return _attributes.attrMap<vertex, Vec3Colorb>("Vertex Axis Color");
    }
 
    bool setVertexAxisColor(const Colorb &pos, const Colorb &neg);
 
    IntMatrix3fMap &vvCorrespondence() 
    {
      return _VVCorrespondence;
    }                                                                    
 
    /*
                                 * Returns a boolean for visualization of lines between corresponding vertices
     */
    bool &showVVCorrespondence() 
    {
      return _showVVCorrespondence;
    }                                                                
  
 
    QString &signalUnit() 
    {
      return _attributes.attrMap<QString, QString>("Vertex Signal Unit")["Vertex Signal Unit"];
    }
 
    Point2f &signalBounds() 
    {      
      return _attributes.attrMap<QString, Point2f>("Vertex Signal Bounds")["Vertex Signal Bounds"];
    }
  
    const BoundingBox3f &boundingBox() const 
    {
      return _bbox;
    }
    BoundingBox3f &boundingBox() 
    {
      return _bbox;
    }
    void setBoundingBox(const BoundingBox3f &bbox) 
    {
      _bbox = bbox;
    }
    void updateBBox();
    int &ccTab()
    {
      return _ccTab;
    }
    QString &ccName()
    {
       return _ccName;
    }
    QString &deleteProcessName(QString &meshType)
    {
      return _attributes.attrMap<QString, QString>("Delete Process Name")[meshType];
    }
 
    static bool meshFromTriangles(vvGraph &S, const std::vector<vertex> &vertices,
                                const std::vector<Point3i> &triangles, bool checkUnique = true);
 
    IntVtxMap &vMap() { return _vMap; }
 
    IntCellMap &cMap() { return _cMap; }
 
    bool readVertices(QIODevice &file, VtxVec &V, bool transform);
 
    bool readVertexList(QIODevice &file, vvGraph &S);
 
    bool readNhbds(QIODevice &file, vvGraph &S);
 
    bool readCellMesh(QIODevice &file, bool transform);
 
    bool read(QIODevice &file, bool transform);
 
    bool writeVertices(QIODevice &file, const vvGraph &S, bool transform);
 
    bool writeVertexList(QIODevice &file, const vvGraph &S);
 
    bool writeNhbds(QIODevice &file, const vvGraph &S);
 
    bool writeCellMesh(QIODevice &file, bool transform);
 
    bool write(QIODevice &file, bool transform);
 
    // Draw a cell
    //void drawCell(const cell &c);
 
    // Draw the nrmls
    //void drawNormals(double s);
 
    // Draw all the lines in the S graph
    //void drawGraph();
     
    // Draw the cell graph
    //void drawCellGraph()
 
    //double calcQuad(const vertex &c, const vertex &k, const vertex &l);
    // Draw a cell face
    //void drawCellFace(const cell &c);
 
    // Draw a cell border
    //void drawCellBorder(const cell &c);
 
    //Palette &palette; // color palette
    //int currLabel;
    //
  private:
    void init();
    void resetModified();
  
    CellTissue T; 
    Attributes _attributes;
 
    TransferFunction _surf_fct, _heat_fct;
    IntMatrix3fMap _VVCorrespondence;
    bool _showVVCorrespondence;
    IntIntSetMap _labelNeighbors;
    IntIntVIdSetMap _wallVId;
    bool changed_surf_function, changed_heat_function;
    int _changed;
    bool _culling, _blending;
    bool _showSurface, _showMesh, _showAxis;
    float _opacity, _brightness;
    SurfView _surfView;
    QString _surfVertexView, _surfTriangleView, _surfLabelView;
    QString _meshView, _axisView;
    bool _showMeshLines, _showMeshPoints, _showMeshCellMap;
                                bool _useParents;
    bool _imgtex;
    QString _file;
    bool _scaled;
    bool _transformed;
    bool _showBBox;
    int _id;
    const Stack* _stack;
    QImage _image;
  
    BoundingBox3f _bbox;
    int _ccTab;
    QString _ccName;
    QString _deleteProcess;
 
    IntVtxMap _vMap; // Map vertex saveId to vertex
    IntCellMap _cMap; // Map cell saveId to vertex
  };
}
 
#endif