gmQuadCellGeometryInfo.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 _GEMA_QUAD_CELL_GEOMETRY_INFO_H_
#define _GEMA_QUAD_CELL_GEOMETRY_INFO_H_
 
#include "gmCellGeometryInfo.h"
#include "gmCellGeometryIntegrationRuleSet.h"
 
#include "gmGeometryUtils.h"
 
#include "gmQuadIntegrationRule.h"
#include "gmQuadShape.h"
 
//---------------------------------------------------------
// Quad integration rules
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSet<GmQuadGaussIntegrationRule,  GmQuadLobattoIntegrationRule,
                                         GmQuadNewtonIntegrationRule, GmQuadNewtonIntegrationRule> GmQuadIntegrationRuleSet;
 
typedef GmCellGeometryIntegrationRuleSet<GmQuadGaussEdgeIntegrationRule,    GmQuadLobattoEdgeIntegrationRule,
                                         GmCellGeometryNullIntegrationRule, GmCellGeometryNullIntegrationRule> GmQuadEdgeIntegrationRuleSet;
 
 
//---------------------------------------------------------
// Quad4 & Quad3D4 rule defaults
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, 2, 2> GmLinearQuadIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 2, 2, -1, -1> GmLinearQuadEdgeIntegrationRuleSetDefaults;
 
//---------------------------------------------------------
// Quad8, Quad3D8 & Quad9 rule defaults
//---------------------------------------------------------
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 3, 3, 3, 3> GmQuadraticQuadIntegrationRuleSetDefaults;
 
typedef GmCellGeometryIntegrationRuleSetDefaultRules<GM_GAUSS_RULE_TYPE, 3, 3, -1, -1> GmQuadraticQuadEdgeIntegrationRuleSetDefaults;
 
 
//---------------------------------------------------------
// GmQuad4CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmQuad4CellGeometryInfo 
  : public GmCellGeometryInfoSurfaceElement<GmQuadIntegrationRuleSet,     GmLinearQuadIntegrationRuleSetDefaults,
                                            GmQuadEdgeIntegrationRuleSet, GmLinearQuadEdgeIntegrationRuleSetDefaults>
{
public:
  static const GmQuad4CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmQuad4Shape; }
 
  virtual double dimension(const GmMatrix& X) const 
  { 
    return GmGeometryUtils::quadArea(X.col(0), X.col(1), X.col(2), X.col(3)); 
  }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const 
  { 
    GmGeometryUtils::quadCentroid(X.col(0), X.col(1), X.col(2), X.col(3), coord); 
  }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const {Q_UNUSED(X); R = arma::eye(2, 2); return false; }
 
  // ---------  Capabilities API ---------
 
  // See comments on the base class
  virtual int isValid(const GmMatrix& X, double tol) const 
  {
    Q_UNUSED(tol);
    int ret = GM_GEOMETRY_STATE_VALID;
    if (!GmGeometryUtils::polygon2DIsCCW(X))             ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
    if (GmGeometryUtils::polygon2DIsSelfIntersecting(X)) ret |= GM_GEOMETRY_STATE_SELF_INTERSECT;
    return ret;
  }
 
  // See comments on the base class
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { return GmGeometryUtils::pointInConvexPolygon(X, coord); }
 
protected:
  GmQuad4CellGeometryInfo(GmCellGeometryMetadata&& metadata)
    : GmCellGeometryInfoSurfaceElement<GmQuadIntegrationRuleSet,     GmLinearQuadIntegrationRuleSetDefaults,
                                       GmQuadEdgeIntegrationRuleSet, GmLinearQuadEdgeIntegrationRuleSetDefaults>(std::move(metadata)) {}
};
 
//---------------------------------------------------------
// GmQuad3D4CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmQuad3D4CellGeometryInfo : public GmQuad4CellGeometryInfo
{
public:
  static const GmQuad3D4CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmQuad3D4Shape; }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix& X, double tol) const {
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon3DIsPlanar(X, tol)) ret |= GM_GEOMETRY_STATE_NON_PLANAR;
      return ret; 
  }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const {Q_UNUSED(X); R = arma::eye(3, 3); return false; }
 
  // contains() capabilities are currently not supported in 3D, so the implementation
  // from Quad4CellGeometryInfo must be overridden. Quality is ok.
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { Q_UNUSED(X); Q_UNUSED(coord); return false; }
 
private:
  GmQuad3D4CellGeometryInfo(const GmQuad4CellGeometryInfo& quad4) : GmQuad4CellGeometryInfo(quad4) {}
};
 
 
//---------------------------------------------------------
// GmQuad8CellGeometryInfo
//---------------------------------------------------------
 
//vertices in circular order
static int quad8order[] = { 0,4,1,5,2,6,3,7 };
 
class GMC_API_EXPORT GmQuad8CellGeometryInfo 
  : public GmCellGeometryInfoSurfaceElement<GmQuadIntegrationRuleSet,     GmQuadraticQuadIntegrationRuleSetDefaults,
                                            GmQuadEdgeIntegrationRuleSet, GmQuadraticQuadEdgeIntegrationRuleSetDefaults>
{
public:
  static const GmQuad8CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmQuad8Shape; }
 
  virtual double dimension(const GmMatrix& X) const { return dimensionByIntegration(X); }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const { centroidByIntegration(X, coord); }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const {Q_UNUSED(X); R = arma::eye(2, 2); return false; }
 
  // ---------  Capabilities API ---------
 
  virtual int isValid(const GmMatrix & X, double tol) const {
      Q_UNUSED(tol);
      //reorder nodes
      GmMatrix Xr = GmGeometryUtils::shuffle(X, quad8order, 8);
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon2DIsCCW(Xr))             ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      if (GmGeometryUtils::polygon2DIsSelfIntersecting(Xr)) ret |= GM_GEOMETRY_STATE_SELF_INTERSECT;
      return ret;
  }
 
  // See comments on the base class
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { return GmGeometryUtils::pointInTesselatedPolygon_Q8(X, coord); }
 
protected:
  GmQuad8CellGeometryInfo(GmCellGeometryMetadata&& metadata)
    : GmCellGeometryInfoSurfaceElement<GmQuadIntegrationRuleSet,     GmQuadraticQuadIntegrationRuleSetDefaults,
                                       GmQuadEdgeIntegrationRuleSet, GmQuadraticQuadEdgeIntegrationRuleSetDefaults>(std::move(metadata)) {}
};
 
//---------------------------------------------------------
// GmQuad3D8CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmQuad3D8CellGeometryInfo : public GmQuad8CellGeometryInfo
{
public:
  static const GmQuad3D8CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmQuad3D8Shape; }
 
  // ---------  Capabilities API ---------
  
  virtual int isValid(const GmMatrix& X, double tol) const { 
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon3DIsPlanar(GmGeometryUtils::shuffle(X, quad8order, 8), tol)) 
          ret |= GM_GEOMETRY_STATE_NON_PLANAR;
 
      return ret;
  }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const {Q_UNUSED(X); R = arma::eye(3, 3); return false; }
 
  // No capabilities are currently supported in 3D, so the contains() implementation
  // from Quad8CellGeometryInfo must be overridden. 
  virtual bool contains(const GmMatrix& X, const GmVector& coord) const { Q_UNUSED(X); Q_UNUSED(coord); return false; }
 
private:
  GmQuad3D8CellGeometryInfo(const GmQuad8CellGeometryInfo& quad8) : GmQuad8CellGeometryInfo(quad8) {}
};
 
//---------------------------------------------------------
// GmQuad9CellGeometryInfo
//---------------------------------------------------------
 
class GMC_API_EXPORT GmQuad9CellGeometryInfo 
  : public GmCellGeometryInfoSurfaceElement<GmQuadIntegrationRuleSet,     GmQuadraticQuadIntegrationRuleSetDefaults,
                                            GmQuadEdgeIntegrationRuleSet, GmQuadraticQuadEdgeIntegrationRuleSetDefaults>
{
public:
  static const GmQuad9CellGeometryInfo* instance();
 
  // Shape factory. See comments on the base class.
  virtual GmShape* shapeInstance(int P, int Q) const { Q_UNUSED(P); Q_UNUSED(Q); return new GmQuad9Shape; }
 
  virtual double dimension(const GmMatrix& X) const { return dimensionByIntegration(X); }
 
  virtual void centroidCartesian(const GmMatrix& X, GmVector& coord) const { centroidByIntegration(X, coord); }
 
  virtual bool localAxis(const GmMatrix&X, GmMatrix& R) const {Q_UNUSED(X); R = arma::eye(2, 2); return false; }
 
  // ---------  Capabilities API ---------
  virtual int isValid(const GmMatrix & X, double tol) const {
      Q_UNUSED(tol);
      //reorder nodes, ignores node 9 (center)
      GmMatrix Xr = GmGeometryUtils::shuffle(X, quad8order, 8);
      int ret = GM_GEOMETRY_STATE_VALID;
      if (!GmGeometryUtils::polygon2DIsCCW(Xr)) ret |= GM_GEOMETRY_STATE_BAD_ORIENTATION;
      if (GmGeometryUtils::polygon2DIsSelfIntersecting(Xr)) ret |= GM_GEOMETRY_STATE_SELF_INTERSECT;
      return ret;
  }
private:
  GmQuad9CellGeometryInfo(const GmQuad8CellGeometryInfo& quad8)
    : GmCellGeometryInfoSurfaceElement<GmQuadIntegrationRuleSet,     GmQuadraticQuadIntegrationRuleSetDefaults,
                                       GmQuadEdgeIntegrationRuleSet, GmQuadraticQuadEdgeIntegrationRuleSetDefaults>(quad8) {}
};
 
 
#endif