gmTriSurfaceDiscontinuity.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2023 by Carlos Augusto Teixeira Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_TRISURFACE_DISCONTINUITY_H_
#define _GEMA_TRISURFACE_DISCONTINUITY_H_

#include "gmDiscontinuity.h"
#include "gmBVHAcceleration.h"
#include "gmCellMesh.h"

class GmTriSurfaceDiscontinuity : public GmDiscontinuity
{
public:
  virtual ~GmTriSurfaceDiscontinuity();

  // See comments on the base class
  virtual int numSegments() const { return _numTriangles; };

  // See comments on the base class
  virtual int numIntersections() const { return intPoint.size(); }

  int numPoints() const { return _numPoints; }

  const double* pointCoordinates() const { return _pointCoord; }

  int numTriangles() const { return _numTriangles; }

  const int* triangleIncidences() const { return _triList; }

  //TODO
  //const auto intersectionList() const {  return cellIntersections; }

  virtual void clearGeometry();

  virtual void printGeometry(const GmLogCategory& logger, GmLogLevel level) const;

  // See comments on the base class
  virtual size_t usedGeometryMemory() const { return _numPoints * 3 * sizeof(double) + _numTriangles * 3 * sizeof(int); }

  virtual size_t usedIntersectionMemory() const {

      return intPoint.size() * sizeof(RayIntersection) + 
             std::accumulate(cellIntersection.begin(), 
                             cellIntersection.end(), 
                             (size_t)cellIntersection.size() * sizeof(CellIntersection),
                             [](size_t v, CellIntersection c) {
                                 return v + c.size() * sizeof(EdgeId);
                             }
             );
  }

  virtual bool   findIntersections(const GmLogCategory& logger);
  virtual void   printIntersections(const GmLogCategory& logger, GmLogLevel level) const;

private:
  GmTriSurfaceDiscontinuity(const GmDiscontinuitySet* ds, int index, QString id, int groupIndex, const QVector<int>& psIndex)
    : GmDiscontinuity(ds, index, id, groupIndex, psIndex), _numPoints(0), _numTriangles(0), _pointCoord(NULL), _triList(NULL) {}

  virtual void setGeometry(double* dvec, int nd, int* ivec, int ni)
  {
    assert(dvec && ivec);
    _numPoints    = nd;
    _numTriangles = ni;
    _pointCoord   = dvec;
    _triList      = ivec;
  }

  friend class GmDiscontinuitySet;

  int     _numPoints;    
  int     _numTriangles; 
  double* _pointCoord;   
  int*    _triList;      

  
  //Map storing <cellId, vector<edgeGlobalId, edgeLocalId>>
  using EdgeId = QPair<size_t, int>;
  using CellIntersection = QVector<EdgeId>;
  QHash<size_t, CellIntersection> cellIntersection;
  QHash<size_t, bool> validCellIntersection;

  //Map storing <edgeGlobalId, RayIntersection>
  QHash<size_t, RayIntersection> intPoint;
  QHash<size_t, bool> validIntPoint;

  int markAmbiguousEdges();
 bool reorderIntersections(CellIntersection& ci, const GmCellGeometryInfo* info);

  QVector<EdgeId> popEdgesOnFace(QVector<EdgeId>& edges, QVector<bool>& FELine);


  using BoolMat = QVector<QVector<bool>>;
  //Edge-Edge index
  QHash<GmCellType, BoolMat> accelEE;
  //Edge-Face index
  QHash<GmCellType, BoolMat> accelFE;
  //Given an faceEdge map, build a matrix[edge1][edge2] = true 
  // if the edge1 and edge2 have a face in common
  BoolMat buildEEMatrix(QVector<QVector<int>> faceEdge, int nedges);
  //Given an edgeFace map, build a matrix[edge][face] = true 
  // if the face contais edge
  BoolMat buildFEMatrix(QVector<QVector<int>> edgeFace, int nface);

  const BoolMat getOrBuildEEMatrix(const GmCellGeometryInfo* info);
  const BoolMat getOrBuildFEMatrix(const GmCellGeometryInfo* info);

  bool checkConsistency();

  //To be removed after validation
  void DebugCell(size_t cellId, GmMatrix& points, CellIntersection& ci);
};


#endif // _GEMA_TRISURFACE_DISCONTINUITY_H_