uibhmQuery.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera 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 _UIBHM_QUERY_H_
#define _UIBHM_QUERY_H_
 
#include "uibhmTopology.h"
 
#include <gmCellMeshTopology.h>
 
template <class Geometry>
class GMP_GEMAMESH_API_EXPORT UibhmQuery : public GmCellMeshTopology
{
public:
 
  // An alias for the topology structure to simplify the call to static functions
  using Topology = UibhmTopology<Geometry>;
 
  // 'Import' the half side type from the topology object
  using HalfSide = typename Topology::HalfSide;
 
  UibhmQuery(UibhmTopology<Geometry>* topology) : _t(topology) { assert(topology); }
 
  // See comments on the base class
  virtual bool hasElementsWithoutTopology() const { return _t->strange(); }
 
  virtual GmCell* adjacentCell(const GmCell* cell, int sideIndex, int* adjSideIndex = NULL) const;
 
  virtual bool isBorderNode(int nodeIndex) const;
 
  // See comments on the base class
  virtual int numBorders() const { return _t->_B.size(); }
 
  virtual int borderIndex(const GmCell* cell, int sideIndex) const;
 
  // See comments on the base class
  virtual void printParameters(const GmLogCategory& logger, GmLogLevel level) const { _t->printParameters(logger, level); }
 
  // See comments on the base class
  virtual void print(const GmLogCategory& logger, GmLogLevel level) const { _t->print(logger, level); }
 
  // See comments on the base class
  virtual size_t printMemoryStatistics(const GmLogCategory& logger, GmLogLevel level) const { return _t->printMemoryStatistics(logger, level); }
 
  // See comments on the base class
  virtual size_t usedMemory() const { return _t->usedMemory(); }
 
protected:
  UibhmTopology<Geometry>* _t; 
};
 
template <class Geometry>
class GMP_GEMAMESH_API_EXPORT UibhmSurfaceQuery : public UibhmQuery<Geometry>
{
public:
  UibhmSurfaceQuery(UibhmTopology<Geometry>* topology) : UibhmQuery<Geometry>(topology) {}
 
  virtual void nodeAdjacentNodes(int nodeIndex, QueryOptions options, QVector<int>& list) const;
  virtual void nodeAdjacentCells(int nodeIndex, QVector<GmCell*>& list) const;
 
  // See comments on the base class
  virtual void nodeAdjacentCells(int nodeIndex, QVector<const GmCell*>& list) const
  {
    // to avoid code duplication, lets just call the non-const version of this function
    nodeAdjacentCells(nodeIndex, (QVector<GmCell*>&)list);
  }
 
  virtual void edgeAdjacentCells(const GmCell* cell, int edgeIndex, QVector<GmCell*>& list) const;
 
  // See comments on the base class
  virtual void edgeAdjacentCells(const GmCell* cell, int edgeIndex, QVector<const GmCell*>& list) const
  {
    // to avoid code duplication, lets just call the non-const version of this function
    edgeAdjacentCells(cell, edgeIndex, (QVector<GmCell*>&)list);
  }
 
  virtual void edgeAdjacentCells(int node1, int node2, QVector<GmCell*>& list) const;
 
  // See comments on the base class
  virtual void edgeAdjacentCells(int node1, int node2, QVector<const GmCell*>& list) const
  {
    // to avoid code duplication, lets just call the non-const version of this function
    edgeAdjacentCells(node1, node2, (QVector<GmCell*>&)list);
  }
 
  virtual GmCell* firstBorderCurveEdge(int borderCurveIndex, int* edgeIndex) const;
  virtual GmCell* nextBorderCurveEdge (const GmCell* cell, int edgeIndex, int* nextEdgeIndex) const;
 
  virtual void*   borderTraverseStart(int borderId) const;
  virtual GmCell* borderTraverseNext(void* context, int* nextSideIndex) const;
  virtual void    borderTraverseEnd(void* context) const;
 
private:
 
  struct TraverseContext { HalfSide _start; HalfSide _last; };
 
  template <class VertexF, class QuadF> 
  void heStar(int node, VertexF vf, QuadF qf, bool addBorder) const;
};
 
template <class Geometry>
class GMP_GEMAMESH_API_EXPORT UibhmSolidQuery : public UibhmQuery<Geometry>
{
public:
  UibhmSolidQuery(UibhmTopology<Geometry>* topology) : UibhmQuery<Geometry>(topology) {}
 
  virtual void nodeAdjacentNodes(int nodeIndex, QueryOptions options, QVector<int>& list) const;
  virtual void nodeAdjacentCells(int nodeIndex, QVector<GmCell*>& list) const;
 
  // See comments on the base class
  virtual void nodeAdjacentCells(int nodeIndex, QVector<const GmCell*>& list) const
  {
    // to avoid code duplication, lets just call the non-const version of this function
    nodeAdjacentCells(nodeIndex, (QVector<GmCell*>&)list);
  }
 
  virtual void edgeAdjacentCells(const GmCell* cell, int edgeIndex, QVector<GmCell*>& list) const;
 
  // See comments on the base class
  virtual void edgeAdjacentCells(const GmCell* cell, int edgeIndex, QVector<const GmCell*>& list) const
  {
    // to avoid code duplication, lets just call the non-const version of this function
    edgeAdjacentCells(cell, edgeIndex, (QVector<GmCell*>&)list);
  }
 
  // See comments on the base class
  virtual void edgeAdjacentCells(int node1, int node2, QVector<GmCell*>& list) const
  {
    edgeAdjacentCells(Topology::encodeEdge(node1, node2), list);
  }
 
  // See comments on the base class
  virtual void edgeAdjacentCells(int node1, int node2, QVector<const GmCell*>& list) const
  {
    edgeAdjacentCells(Topology::encodeEdge(node1, node2), list);
  }
 
  // See comments on the base class. 
  virtual void edgeAdjacentCells(size_t encodedEdge, QVector<GmCell*>& list) const;
 
  // See comments on the base class
  virtual void edgeAdjacentCells(size_t encodedEdge, QVector<const GmCell*>& list) const
  {
    // to avoid code duplication, lets just call the non-const version of this function
    edgeAdjacentCells(encodedEdge, (QVector<GmCell*>&)list);
  }
 
  // See comments on the base class
  virtual GmCell* firstBorderCurveEdge(int borderCurveIndex, int* edgeIndex) const
  {
    Q_UNUSED(borderCurveIndex); Q_UNUSED(edgeIndex);
    assert(0); // should not be called for solid meshes
    return NULL;
  }
 
  // See comments on the base class
  virtual GmCell* nextBorderCurveEdge(const GmCell* cell, int edgeIndex, int* nextEdgeIndex) const
  {
    Q_UNUSED(cell); Q_UNUSED(edgeIndex); Q_UNUSED(nextEdgeIndex);
    assert(0); // should not be called for solid meshes
    return NULL;
  }
 
  virtual void*   borderTraverseStart(int borderId) const;
  virtual GmCell* borderTraverseNext(void* context, int* nextSideIndex) const;
  virtual void    borderTraverseEnd(void* context) const;
 
private:
  template <class QueryF>
  bool traverseCells(int nodeIndex, int cellId, QueryF f) const;
 
  template <class QueryF>
  bool traverseAroundFlowNode(int nodeIndex, QueryF f) const;
 
  template <class QueryF>
  void traverseEdgeAdjacentCellsByNodeQuery(int v1, int v2, QueryF f) const;
 
  bool edgeAdjacentCells(HalfSide hf, int v1, int v2, QVector<GmCell*>& list) const;
};
 
#endif