gmPolylineDiscontinuity.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_POLYLINE_DISCONTINUITY_H_
#define _GEMA_POLYLINE_DISCONTINUITY_H_
 
#include "gmDiscontinuity.h"
#include "gmSegmentCellIntersection.h"
 
class GmCell;
class GmCellMesh;
class GmValueAccessor;
 
 
class GmPolylineSegment;
 
class GmPolylineDiscontinuity : public GmDiscontinuity
{
public:
  virtual ~GmPolylineDiscontinuity();
 
  // See comments on the base class
  virtual int numElements() const { return _numPoints ? _numPoints-1 : 0; };
 
  // See comments on the base class
  virtual int numPoints() const { return _numPoints; };
 
  // See comments on the base class
  virtual int numIntersections() const { return _intList.size(); }
 
  // See comments on the base class
  virtual bool extendGeometry(GmCellMesh* sMesh, double size, const GmLogCategory& logger);
 
  const double* pointCoordinates() const { return _pointCoord; }
 
  const QVector<GmCompact2DSegmentCellIntersection*>& intersectionList() const { return _intList; }
 
  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 * 2 * sizeof(double); }
 
  virtual bool   findIntersections (const GmLogCategory& logger);
  virtual void   printIntersections(const GmLogCategory& logger, GmLogLevel level) const;
 
  // See comments on the base class
  virtual size_t usedIntersectionMemory() const { return _intList.capacity() * sizeof(GmCompact2DSegmentCellIntersection*) +
                                                         _intList.size()     * sizeof(GmCompact2DSegmentCellIntersection); }
 
private:
  friend class GmDiscontinuitySet;
 
  GmPolylineDiscontinuity(const GmDiscontinuitySet* ds, int index, QString id, int groupIndex, const QVector<int>& psIndex)
    : GmDiscontinuity(ds, index, id, groupIndex, psIndex), _numPoints(0), _pointCoord(NULL) {}
 
  virtual void setGeometry(double* dvec, int nd, int* ivec, int ni) 
  { 
    Q_UNUSED(ni); Q_UNUSED(ivec);
    assert(dvec && !ivec); 
    _numPoints  = nd;
    _pointCoord = dvec;
  }
 
  virtual bool loadGeometryFromTable(LuaTable& tab, const GmLogCategory& logger);
 
  GmSegmentCellIntersection segmentConvexLinearElementIntersection(const GmPolylineSegment& segment, int segmentId, const GmCell* cell,
                                                                   const GmValueAccessor* coordAc, int incomingBorder, double snapTol, 
                                                                   bool* intersects, double inout[2], bool snap[2], int* outgoingBorder,
                                                                   const GmLogCategory& logger) const;
 
  GmSegmentCellIntersection findSegmentEntryPoint(const GmPolylineSegment& segment, int segmentId, const GmValueAccessor* coordAc,
                                                  double snapTol, bool* intersects, double inout[2], bool snap[2], int* outgoingBorder, 
                                                  GmCell const** cell, const GmLogCategory& logger) const;
 
  void removeInternalNodes(const GmValueAccessor* coordAc, double snapTol, const GmLogCategory& logger);
 
  bool checkMeshPreconditions(const GmCellMesh* mesh, const GmLogCategory& logger) const;
 
  const GmCell*    findAdjacentCell (const GmCellMesh* mesh, const GmCell* cell, int edgeIndex, int* adjCellEdge) const;
  QVector<GmCell*> findNodeCellsBall(const GmCellMesh* mesh, int nodeIndex) const;
 
  static bool segmentIntersection(const GmCompact2DSegmentCellIntersection* firstSegment, const GmCompact2DSegmentCellIntersection* secondSegment,
                                  double* firstPos, double* secondPos, GmVector& cartPos);
 
  bool breakIntersectionSegment(GmCompact2DSegmentCellIntersection* segment, double natPos, const GmVector& cartPos, GmValueAccessor* coordAc,
                                GmCompact2DSegmentCellIntersection** newSegment, const GmLogCategory& logger);
  void intersectionSegmentBreakingEnded();
 
  int     _numPoints;   
  double* _pointCoord;  
 
  QVector<GmCompact2DSegmentCellIntersection*> _intList;
 
  QVector<QPair<int, QVector<GmCompact2DSegmentCellIntersection*>>> _brokenList;
 
  friend class GmDiscontinuitySetStateDumpItem;
  friend QDataStream& operator<<(QDataStream&, const GmDiscontinuitySet&);
  friend QDataStream& operator>>(QDataStream&, GmDiscontinuitySet&);
};
 
 
#endif // _GEMA_POLYLINE_DISCONTINUITY_H_