gmSegmentCellIntersection.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_SEGMENT_CELL_INTERSECT_H_
#define _GEMA_SEGMENT_CELL_INTERSECT_H_
 
#include "gmLog.h"
#include "gmVector.h"
#include <QDataStream>
 
class GmPCR;
 
enum GmSegmentCellIntersectionPointKind
{
  GM_NO_INTERSECTION,        
  GM_NODE_INTERSECTION,      
  GM_EDGE_INTERSECTION,      
  GM_FACE_INTERSECTION,      
  GM_INTERNAL_INTERSECTION,  
  //------------------------
  // Please do not change this enumeration without also changing the static
  // GmSegmentCellIntersection::kindToStr() method
  GM_NUM_INTERSECTION_POINT_KIND 
};
 
 
struct GMC_API_EXPORT GmSegmentCellIntersection
{
public:
  typedef QPair<int, int> SegmentId; 
 
  // Intersection point data
  struct IntersectionPoint
  {
    GmVector  _cartCoord; 
    GmVector  _natCoord;  
    GmSegmentCellIntersectionPointKind _kind;      
    int       _border;    
 
    IntersectionPoint() : _kind(GM_NO_INTERSECTION), _border(-1) {}
    void set(const GmVector& cc, GmSegmentCellIntersectionPointKind kind, int border)
    {
      _cartCoord = cc;
      _kind      = kind;
      _border    = border;
    }
  };
 
  int        _cellId;    
  SegmentId  _segmentId; 
 
  IntersectionPoint _in;  
  IntersectionPoint _out; 
 
  int  _edge;       
  int  _face;       
  bool _continuous; 
  bool _single;     
  GmVector _normal; 
 
  static const char* kindToStr(GmSegmentCellIntersectionPointKind kind);
 
  void print(const GmPCR* pcr, const GmLogCategory& logger, GmLogLevel level) const;
};
 
class GMC_API_EXPORT GmCompact2DSegmentCellIntersection
{
public:
  typedef QPair<int, int> SegmentId; 
 
  int cellId() const { return _cellId; }
 
  SegmentId segmentId() const { return _segmentId; }
 
  void setSegmentIdIndex(int index) { _segmentId.second = index; }
 
  GmSegmentCellIntersectionPointKind kind(int i) const
  {
    assert(i == 0 || i == 1);
    if(i == 0)
      return (GmSegmentCellIntersectionPointKind)(_kindAndFlags & 0x07);
    else
      return (GmSegmentCellIntersectionPointKind)((_kindAndFlags >> 3) & 0x07);
  }
 
  int border(int i) const { assert(i == 0 || i == 1); return _border[i]; }
 
  int edge() const 
  {
    // Since the edge can be -1, for the code  below to work we need a signed right shift
    // to be an arithmetic shift.
    // Until c++ 20, right shifts on signed numbers where implementation defined behaviour,
    // but implemented as expected in every sane compiler (using two's complement)
    // The assert  below checks that so we can have peace of mind.
    //                01010101 >> 1 == 00101010            10101010 >> 1 == 11010101           
    static_assert(((qint8)0x55 >> 1 == (qint8)0x2A) && ((qint8)0xAA >> 1 == (qint8)0xD5), "signed right shift is NOT an arithmetic shift");
    return (qint8)_edgeAndNatSize >> 2;
  }
 
  GmVector cartCoord(int i) const { assert(i == 0 || i == 1); GmVector v(2); v[0] = _cartCoord[2*i]; v[1] = _cartCoord[2*i+1]; return v; }
 
  const double* rawCartCoord(int i) const { assert(i == 0 || i == 1); return &_cartCoord[2*i]; }
 
  GmVector natCoord(int i) const
  { 
    assert(i == 0 || i == 1); 
    int           n     = numNatCoordinates();
    const double* ncptr = _natCoord + hasIntersectionElementId();
 
    GmVector v(n); 
    for(int j = 0; j < n; j++)
      v[j] = ncptr[n*i + j];
    return v; 
  }
 
  GmVector normal() const { return GmVector({ _normal[0], _normal[1] }); }
 
  bool continuous() const { return _kindAndFlags & 0x40; }
 
  void setContinuous(bool mode)
  {
    if(mode)
      _kindAndFlags |= 0x40;  // Set bit 7
    else
      _kindAndFlags &= (~0x40); // Clear bit 7
  }
 
  bool segmentIntersection() const { return _kindAndFlags & 0x80; }
 
  void setSegmentIntersection() { _kindAndFlags |= 0x80; }
 
  bool hasIntersectionElementId() const { return _edgeAndNatSize & 0x02; }
 
  // Returns the stored intersection element id or -1 if not stored
  int intersectionElementId() const { return hasIntersectionElementId() ? _natCoord[0] : -1; }
 
  void setIntersectionElementId(int id) { assert(hasIntersectionElementId()); _natCoord[0] = id; }
 
  void updateOutputData(const GmCompact2DSegmentCellIntersection* out, int edge);
  void updateOutputData(const GmVector& cartCoord, const GmVector& natCoord, GmSegmentCellIntersectionPointKind kind, int border);
 
  void print(const GmPCR* pcr, const GmLogCategory& logger, GmLogLevel level) const;
 
  size_t memSize() const { 
      size_t elemIdSize = hasIntersectionElementId() ? 1 : 0;
      return sizeof(GmCompact2DSegmentCellIntersection) + (2 * numNatCoordinates() - 1 + elemIdSize) * sizeof(double);
  }
 
  static GmCompact2DSegmentCellIntersection* instance(const GmSegmentCellIntersection& data, int segmentIndex, bool hasIntElementId);
 
  void operator delete(void* ptr);
  void operator delete(void* ptr, int, bool);
 
private:
  Q_DISABLE_COPY(GmCompact2DSegmentCellIntersection);
 
  GmCompact2DSegmentCellIntersection(const GmSegmentCellIntersection& data, int segmentIndex, bool hasIntElementId);
 
  void* operator new(std::size_t count, int nnatural, bool hasIntElementId);
 
  void updateNormal(const GmCompact2DSegmentCellIntersection* out);
 
  int numNatCoordinates() const { return 2 + (_edgeAndNatSize & 0x01); }
 
  int        _cellId;    
  SegmentId  _segmentId; 
 
  // The above fields are stored in 3 ints, or 12 bytes. For an 8 bytes alignment, before the coordinate
  // vectors (storing doubles), we have a 4 bytes zone that will be filled with the remaining data.
  // - Both in and out intersection kinds will be compacted in the 6 lower bits. The remaining two high 
  //   bits are used to store flags for continuous segments (bit 7) and for segments belonging to an inter 
  //   segments intersection (bit 8).
  // - Each in and out border value will get its own byte. We could compact them in a single byte 
  //   (taking care with the value sign since it can store -1) but since we have 4 bytes to spend  
  //   we leave each one in its own field
  // - The edge field is stored in the six most significant bits of the fourth byte. We use the 
  //   two lower bits to store whether we have a third natural coordinate (bit 1 set to 1) and 
  //   whether we have an associated intersection element id stored "as contraband" in the 
  //   begining of the _natCoord flexible array (bit 2 set to 1). By doing that we get the flexibility 
  //   of paying the price for storing the id only if needed. Please keep in mind that, due to 8 bytes 
  //   alignment, adding an extra int id field after _edgeAndNatSize,  would take the same 8 bytes 
  //   space as the double used to store it in the _natCoord vector.
  
  quint8 _kindAndFlags; 
 
  qint8  _border[2];    
 
  quint8  _edgeAndNatSize; 
 
  double _cartCoord[4]; 
 
  double _normal[2];
 
  double _natCoord[1];
 
  //QT serialization operators
  friend QDataStream& operator<<(QDataStream&, const GmCompact2DSegmentCellIntersection*);
  friend QDataStream& operator>>(QDataStream&, GmCompact2DSegmentCellIntersection*&);
};
 
 
 
 
#endif // _GEMA_SEGMENT_CELL_INTERSECT_H_