DivisionAnalysisUtils.hpp

Go to the documentation of this file.

#ifndef DivisionAnalysisUtils_H
#define DivisionAnalysisUtils_H
 
#include <Process.hpp> // for vvGraph, forall, ...
#include <GraphUtils.hpp> // for neighborhoodGraph
#include <GraphAlgorithms.hpp>
 
//#include "DivisionAnalysisData.hpp"
 
 
using namespace std;
 
// DivisionAnalysisUtils contains typedefs and class-independent helper-functions for the DivisionAnalysis AddOn
namespace mgx
{
 
  typedef std::pair<Point3d, double> P3dDouble;
 
  typedef std::pair<cell, double> VtxDouble;
  typedef std::pair<std::set<cell>, std::set<cell> > CellSetPair;
  typedef std::pair<cell,cell> cCPair;
  typedef std::pair<Point3d, bool> P3dboolPair;
  typedef std::pair<cell, double> cellDPair;
 
  typedef std::pair<Point3d, int> P3dInt;
  typedef std::pair<P3dDouble, double> P3dDD;
  typedef std::pair<Point3d,Point3d> P3dP3d;
 
 
  typedef std::pair<int, int> IntInt;
  typedef std::pair<IntInt, double> IntIntDouble;
  typedef std::pair<vertex, vertex> VtxVtx;
  typedef std::pair<VtxVtx, vertex> Tri;
  typedef std::pair<VtxVtx, vertex> Vtxvtxp;
  typedef std::pair<vertex, int> VtxInt;
 
 // typedef pair<IntInt, double> IID;
 
  //typedef Vector<3, vertex> tri;
  typedef pair<Triangle, int> TriInt;
 
   bool writeCsvFile(QString filename, QString header, vector<vector<double> >& data);
 
   double calcRatio(double value1, double value2);
 
   double avgCellSizeMGX3D(const cell &c);
 
   double divisionPlaneArea(Point3d cellCenter, const std::vector<Point3d>& v);
 
   double divisionPlaneAreaMulti(Point3d cellCenter, const std::vector<std::vector<Point3d> >& vMulti);
 
   bool findCell(cellGraph& C, cell& searchedCell, int label, int& maxLabel);
 
   void calcCellGraphJoinedCells(cellGraph &C, const cell& c1, const cell& c2);
 
   void copyCellGraph(CellTissue &orig, CellTissue &copy);
 
   std::vector<Point3d> getSharedVtxs(const cell& c1, const cell& c2);
 
   std::set<Triangle> getSharedTris(const cell& c1, const cell& c2);
 
   double calcTriArea(std::set<Triangle>& tris);
 
   void calcJoinedCell(const cell& c1, const cell& c2, vvGraph& result, bool simple);
 
   void generateSamplingDirectionsNew(int nrPlanes, int centerVarSteps, double centerVarStepSize, std::vector<P3dDouble>& samplingDirections);
   void generateSamplingDirections(double resolution, int centerVarSteps, double centerVarStepSize, std::vector<P3dDouble>& samplingDirections);
 
   void generateSamplingDirections(double resolution, int centerVarSteps, double centerVarStepSize,
    Point3d perpendicularPlane, std::set<Point3d> perpPlaneNormals2, bool enforceDivThroughNeighbor,
    std::vector<P3dDouble>& samplingDirections);
 
void addCenterDisplacementTestCut(int centerVarSteps, double centerVarStepSize, Point3d cellCenter, Point3d perpendicularPlane,
  std::set<Point3d> perpPlaneNormals2,
  std::unordered_map<Point3d, Point3d>& wallCenter, std::unordered_map<Point3d, std::vector<Point3d> > wallPoints,
  std::vector<P3dDouble>& samplingDirections);
 
double calcVolume(vector<Triangle> tris);
 
bool planeSegmentIntersect(const Point3d &p, const Point3d &nrml, const Point3d &u1, const Point3d &u2, Point3d &intersectP);
 
void findNeighbTris(cellGraph& C, const cell& c, std::map<cell, std::vector<Triangle> >& neighbTris);
 
// creates a map of all tris of a cell to the label of the neighbor cell, -1 if theres none
void cellTriNeighbors(cellGraph& C, const cell& c, std::map<Triangle, int>& trisNeighbMap);
 
  // estimates the volume of a 3D body with 1 open side, open Edges need to be oriented right
double estimateVolumeOpenBody(std::vector<Triangle> tris, set<vertex>& exposedVtxs);
 
// estimate the volume of the non-closed daughter cells
void estimateVolumeDaughterCells(std::vector<Triangle>& trisLeft, std::vector<Triangle>& trisRight, std::vector<Triangle>& trisSplit);
 
 // returns the labels of all neighbors of a vertex
 //std::set<int> getNeighborLabels(vvGraph& S, const vertex& v);
 
   // calculates the random walk betweeness centrality for the (weighted) cell graph
 
  void calcRandWalkBetweenness(std::map<IntInt, double>& neighborhoodWeights, std::map<int, int>& labelPosMap, std::vector<int>& orderedLabels,
                               std::map<int, double>& cellBetweenessMap, bool useGPU);
 
 
   void calcRandWalkBetweenness(cellGraph &C, std::map<IntInt, double>& weights, std::map<cell, double>& cellBetweenessMap,
      bool useGPU, bool doRevCuthill);
 
   void calcRandWalkBetweenness(std::map<IntInt, double>& neighborhoodGraph, std::map<int, double>& labelBetweenessMap, bool useGPU);
 
void separateIdenticalVtxs(const cell &c);
 
bool planePolygonIntersect(Point3d planeNrml, Point3d planePos, std::vector<Point3d> polygonVtxs);
 
std::vector<Triangle> getTrisOfCells(Mesh *m, int selectedLabel, bool parentMode);
 
std::vector<vertex> getVtxsOfCells(Mesh *m, int selectedLabel, bool parentMode);
 
std::vector<vertex> getOrRemoveCommonWall(Mesh *m, std::vector<vertex>& cellVtxs, bool removeCommon, bool includeEdgeOfShared);
 
std::vector<Triangle> getOrRemoveCommonWall(Mesh *mesh, std::vector<Triangle>& cellTris, bool removeCommon, bool mergeDuplicated);
 
typedef std::pair<Point3d, Point3d> PlaneNrmlPoint;
 
  void assembleCellFromWalls(vvGraph& S, std::vector<vertex> vtxs, std::vector<Point3i> tris,
    std::set<vertex> &borderVtxs, double mergingThreshold, int labelCounter, bool orientCheck);
 
 
 
}
 
#endif