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:
  enum class CellIntersectionType {
    COMPLETE,
    PARTIAL,
    EXTENDED,
    AMBIGUOUS,
    EMPTY,
  };
 
  const char* ciTypeToStr(const CellIntersectionType t) const {
    switch (t) {
      case CellIntersectionType::EMPTY:
        return "empty";
      case CellIntersectionType::COMPLETE:
        return "complete";
      case CellIntersectionType::PARTIAL:
        return "partial"; 
      case CellIntersectionType::EXTENDED:
        return "extended";
      case CellIntersectionType::AMBIGUOUS:
        return "ambiguous";
      default:
        return "unknow";
    }
  }
 
  using EdgeId = QPair<int, signed char>;
  using CellIntersection = QVector<EdgeId>;
  using BoolMat = QVector<QVector<bool>>;
 
  virtual ~GmTriSurfaceDiscontinuity();
 
  // See comments on the base class
  virtual int numElements() const { return _numTriangles; };
 
  // See comments on the base class
  virtual int numIntersections() const { return _intPoint.size(); }
 
  virtual bool extendGeometry(GmCellMesh* sMesh, double size, const GmLogCategory& logger);
 
  virtual int numPoints() const { return _numPoints; }
 
  const double* pointCoordinates() const { return _pointCoord; }
 
  int numTriangles() const { return _numTriangles; }
 
  int numOriginalTriangles() const { return _originalNumTriangles;  }
 
  const int* triangleIncidences() const { return _triList; }
 
  const QHash<int, CellIntersection>& intersectionEdgeList() const {  return _cellIntersection; }
  const QHash<int, CellIntersectionType>& intersectionTypeList() const { return _cellIntersectionType; }
  const QVector<bool>& validIntersectionPointList() const { return _validIntPoint; }
  const QSet<int>& extendedCellSet() const { return _extendedCell; }
  const QVector<RayIntersection>& intersectionPointList() const { return _intPoint; }
 
  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;
 
  const BoolMat& getOrBuildEEMatrix(const GmCellType type);
  const BoolMat& getOrBuildFEMatrix(const GmCellType type);
 
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), _invalidCellCount(0), _validCellCount(0), _originalNumTriangles(0) {}
 
  virtual void setGeometry(double* dvec, int nd, int* ivec, int ni)
  {
    assert(dvec && ivec);
    _numPoints    = nd;
    _originalNumTriangles = _numTriangles = ni;
    _pointCoord   = dvec;
    _triList      = ivec;
 
  }
  virtual bool loadGeometryFromTable(LuaTable& tab, const GmLogCategory& logger);
 
  friend class GmDiscontinuitySet;
 
  int     _numPoints;    
  int     _numTriangles; 
  double* _pointCoord;   
  int*    _triList;      
 
  //Extended surface data
  int _originalNumTriangles;
 
  //Map storing <cellId, vector<edgeGlobalId, edgeLocalId>>
 
  QHash<int, CellIntersection> _cellIntersection;
  QHash<int, CellIntersectionType> _cellIntersectionType;
  QSet<int> _extendedCell;
 
  //Map storing <edgeGlobalId, RayIntersection>
  QVector<RayIntersection> _intPoint;
  QVector<bool> _validIntPoint;
  QSet<int> _ambiguousCells;
  int _invalidCellCount;
  int _validCellCount;
 
  int markAmbiguousEdges();
 
  CellIntersectionType reorderIntersections(CellIntersection& ci, const GmCellType type, bool removeInvalid = true);
 
  CellIntersection correctOrientation(CellIntersection& ci);
 
  QVector<EdgeId> popEdgesOnFace(QVector<EdgeId>& edges, const QVector<bool>& FELine);
 
 
  //Edge-Edge index
  QHash<GmCellType, BoolMat> _accelEE;
  //Edge-Face index
  QHash<GmCellType, BoolMat> _accelFE;
  //Node-Node -> edgeId index
  QHash<GmCellType, QVector<QVector<signed char>>> _accelNN;
  //Given an faceEdge map, build a matrix[edge1][edge2] = true 
  // if the edge1 and edge2 have a face in common
  BoolMat buildEEMatrix(const QVector<QVector<int>>& faceEdge, int nedges);
  //Given an edgeFace map, build a matrix[edge][face] = true 
  // if the face contais edge
  BoolMat buildFEMatrix(const QVector<QVector<int>>& edgeFace, int nface);
 
  //Checks wether valid cells are globally consistenty with no holes on a face.
  bool checkConsistency();
 
  void clearIntersections() {
      _cellIntersection.clear();
      _cellIntersectionType.clear();
      _intPoint.clear();
      _validIntPoint.clear();
      _ambiguousCells.clear();
      _extendedCell.clear();
      _invalidCellCount = 0;
      _validCellCount = 0;
  }
  
  friend class GmDiscontinuitySetStateDumpItem;
  friend QDataStream& operator<<(QDataStream&, const GmDiscontinuitySet&);
  friend QDataStream& operator>>(QDataStream&, GmDiscontinuitySet&);
 
  //To be removed after validation
  void DebugCell(int cellId, GmMatrix& points, CellIntersection& ci);
  void DebugSurface();
  bool checkCoherence();
};
 
 
#endif // _GEMA_TRISURFACE_DISCONTINUITY_H_