GraphUtils.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 GRAPH_UTILS_HPP
#define GRAPH_UTILS_HPP
 
#include <Config.hpp>
#include <Misc.hpp>
#include <Subdivide.hpp>
#include <Attributes.hpp>
 
namespace mgx
{
  typedef std::pair<int, int> IntInt;
  typedef std::pair<IntInt, double> IntIntDouPair;
  typedef std::vector<Triangle> triVector;
 
  mgx_EXPORT bool subdivideBisect(vvGraph &S, const vertex &v1, const vertex &v2, 
                                      const vertex &v3, VtxVec* vs = 0, Subdivide *sDiv = 0);
 
  template<typename GraphT> 
  bool spliceNhbs(GraphT &S, typename GraphT::vertex_t a, typename GraphT::vertex_t b)
  { 
    typename GraphT::vertex_t n = S.nextTo(b, a);
    typename GraphT::vertex_t pv = b;
 
    if(!S.edge(a,b) or !S.edge(b,a))
      return false;
 
    while(n != a) {
      if(!S.edge(a, n)) {
        S.spliceAfter(a, pv, n);
        S.spliceAfter(n, b, a);
      }
      pv = n;
      n = S.nextTo(b, n);
    }
    return true;
  }
 
  mgx_EXPORT int getLabel(const vertex &v1, const vertex &v2, const vertex &v3);
 
  mgx_EXPORT bool getLabelCount(const vvGraph &S, VtxIntMap &labCount);
 
  mgx_EXPORT bool splitEdge(vvGraph &S, vertex v1, vertex v2, Subdivide *sDiv = 0);
 
  mgx_EXPORT int mergeVertices(vvGraph &S, const VtxVec &vs);
 
  mgx_EXPORT bool checkBorderTris(const vvGraph &S, bool select = true);
 
  mgx_EXPORT bool deleteCells(vvGraph &S, const VtxVec &V);
 
  mgx_EXPORT int fixBorderTris(vvGraph &S);
 
  mgx_EXPORT bool mgxmToMgxc(const vvGraph &srcS, vvGraph &S, double wallMax = 0);
 
  mgx_EXPORT void markMargins(vvGraph &M, vvGraph &S, bool remborders = true);
 
  mgx_EXPORT void markMargins(vvGraph &S, bool remborders = true);
 
  mgx_EXPORT void markMargin(vvGraph &S, vertex v, bool remborders = true);
 
  mgx_EXPORT int setNormals(const vvGraph &S);
 
  mgx_EXPORT void correctNormals(vvGraph &S);
 
  mgx_EXPORT bool setNormal(const vvGraph &S, const vertex &v);
 
  mgx_EXPORT bool calcNormal(const vvGraph &S, const vertex &v, Point3d &nrml);
 
 
  typedef std::map<Point3i, std::set<int> > Point3iIntSetMap;
  typedef std::pair<Point3i, std::set<int> > Point3iIntSetPair;
 
  // object to return output information of neighborhoodGraph
  // currently used by cellmaker (label walls) and cellatlas (wall areas)
  struct NhbdGraphInfo{
 
    // cell label -> wall area of cell
    std::map<int,double> cellWallArea;
 
    // cell label -> wall area of cell that is not shared with other cells
    std::map<int,double> outsideWallArea;
 
    // cell label 1, cell label 2 -> shared wall area between the cells
    std::map<IntInt, double> sharedWallArea;
 
    // cell label 1, cell label 2 -> set of tri pairs that are identical
    std::map<IntInt, std::set<std::pair<Triangle,Triangle> > > sharedTris;
 
    // vertex -> unique wall label 
    std::map<vertex, int> vtxNewLabelMap;
    // vertex -> number of cells this vtx belongs to
    std::map<vertex, int> vtxCellCounterMap;
 
    // map from two labels to their wall label (0 for second label if outside)
    std::map<IntInt, int> allWalls;
  };
  mgx_EXPORT bool neighborhoodGraph(const vvGraph& S, double tolerance, NhbdGraphInfo& info, bool throwError = true);
 
  mgx_EXPORT std::vector<int> findAllLabels(const vvGraph& S);
  mgx_EXPORT std::set<int> findAllLabelsSet(const vvGraph& S);
 
  mgx_EXPORT std::set<int> findAllSelectedLabels(const vvGraph& S);
 
 
  mgx_EXPORT void neighborhood2D(vvGraph& S, std::map<IntInt, double>& neighMap, QString weightType = "", bool ignoreOutside = true);
  mgx_EXPORT vertex nearestVertexOnMesh(const Point3d& targetPoint, const vvGraph& S);
  mgx_EXPORT Point3d nearestPointOnMesh(const Point3d& targetPoint, const vvGraph& S);
 
 
 
  // dijkstra on vvGraph with selected cells
  mgx_EXPORT std::map<int, double> dijkstra
  (vvGraph& S, std::map<IntInt, double>& wallAreas, std::set<int>& selectedCells,
   bool equalWeights, double cutOffDistance, double wallThreshold);
 
  // dijkstra with selected cells
  mgx_EXPORT std::map<int, double> dijkstra
  (std::set<int>& allCellLabels, std::map<IntInt, double>& wallAreas, std::set<int>& selectedCells,
   bool equalWeights, double cutOffDistance, double wallThreshold);
 
  // dijkstra with initial values
  mgx_EXPORT std::map<int, double> dijkstra
  (std::set<int>& allCellLabels, std::map<IntInt, double>& wallAreas, std::map<int, double>& initialCells,
   bool equalWeights, double cutOffDistance, double wallThreshold);
 
  mgx_EXPORT std::set<int> aStar
  (std::vector<int>& uniqueLabels, std::map<int, Point3d>& cellCentroids, std::map<IntInt, double>& wallAreas,
   int label1, int label2, double wallThreshold, bool equalWeights);
 
 
 
 
 
  mgx_EXPORT bool findIntersectPoint(Point3d coordCellCentroid, Point3d& dirVec, std::vector<Triangle>& cellTriangles, int& stopCounter, Point3d& intersectP);
 
  mgx_EXPORT double estimateCellLength(int currentLabel, Point3d coordCellCentroid, Point3d& dirVec, triVector& cellTriangles);
 
  
  mgx_EXPORT void generateLabelTriangleMap(const vvGraph& S, std::map<int, triVector>& cellTriangles);
 
  mgx_EXPORT std::map<int, std::vector<vertex> > generateLabelVertexMap(const vvGraph& S);
 
   // return the border vtxs of a 2D cell
   mgx_EXPORT void findBorderVerticesOfCell(vvGraph& S, int cellLabel, std::set<vertex>& verticesCell, std::vector<vertex>& borderVerticesOrdered);
 
   mgx_EXPORT void findBorderVerticesOfCellsCombined(vvGraph& S, std::set<int> cellLabels, std::set<vertex>& verticesCells, std::vector<vertex>& borderVerticesOrdered);
 
   mgx_EXPORT Point3i triIndex(Point3i t);
   mgx_EXPORT int vIndex(const Point3d &pos, Point3dIntMap &vMap, float tolerance);
 
   // used for circular histogram processes
   mgx_EXPORT int getKeyOfMaxValue(const std::map<int, double>& mapToTest);
   mgx_EXPORT std::map<int,int> shiftMap(std::map<int, double>& mapToShift, int shift);
 
}
#endif