polygon.hh

Go to the documentation of this file.

/*****************************************************************************
*   This program is part of the msbGrid software                            *
*                                                                           *
*   msbGrid stands for multi-structured block Grid generator                *
*                                                                           *
*   msbGrid is a free software: you can redistribute it and/or modify       *
*   it under the terms of the GNU General Public License as published by    *
*   the Free Software Foundation, either version 2 of the License, or       *
*   (at your option) any later version.                                     *
*                                                                           *
*   msbGrid is distributed in the hope that it will be useful,              *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
*   GNU General Public License for more details.                            *
*                                                                           *
*   See the file COPYING for full copying permissions.                      *
*****************************************************************************/
#ifndef _POLYGON_HH_
#define _POLYGON_HH_

#include <algorithm>
#include <cell.hh>

namespace msbGrid
{
template< typename EntityT > /* EntityT can be Point or Edge */
struct EntityAngle
{
  EntityT *entPtr;
  Scalar angle;
};

/*
 * Sort Container by angle
 */
template< typename EntityT >
bool sortByAngle(const EntityAngle< EntityT > &entAngle1, const EntityAngle< EntityT > &entAngle2)
{ return entAngle1.angle < entAngle2.angle; }
} /* namespace msbGrid */

namespace msbGrid
{
template< int EdgeNumber >
class Polygon;
}

template< int EdgeNumber >
class msbGrid :: Polygon : public msbGrid :: Cell
{
public:
  typedef msbGrid :: Cell ParentT;
  typedef Polygon< EdgeNumber > ThisT;

  typedef ParentT :: Point Point;
  typedef ParentT :: Edge Edge;
  typedef msbGrid :: Cell Cell;

  enum { dim = 2 };

  static const int edgeNumber_ = EdgeNumber;
  static const int verticesNumber_ = edgeNumber_;

public:
  Polygon(const std :: vector< Edge * > vEd0) : ParentT()
  {
    assert(dim == 2);
    assert(vEd0.size() == edgeNumber_);

    this->pos().clear();
    for ( unsigned int iDim = 0; iDim < dim; ++iDim ) {
      Scalar som = 0.0;
      for ( unsigned int iEd1 = 0; iEd1 < edgeNumber_; ++iEd1 ) {
        som += vEd0 [ iEd1 ]->pos() [ iDim ];
      }

      som /= edgeNumber_;

      this->pos().push_back(som);
    }

    std :: vector< Edge * > vEd1( sortContainer_( vEd0 ) );
    for ( unsigned int iEd1 = 0; iEd1 < edgeNumber_; ++iEd1 ) {
      this->vEd().push_back(vEd1 [ iEd1 ]);
    }

    std :: vector< Point * > vPt1;
    for ( unsigned int iEd1 = 0; iEd1 < edgeNumber_; ++iEd1 ) {
      for ( unsigned int iPt1 = 0; iPt1 < Edge :: verticesNumber_; ++iPt1 ) {
        bool alreadyTaken = false;
        for ( unsigned int iPt2 = 0; iPt2 < vPt1.size(); ++iPt2 ) {
          if ( this->vEd() [ iEd1 ]->vPt() [ iPt1 ]->isIt(vPt1 [ iPt2 ]) ) {
            alreadyTaken = true;
          }
        }

        if ( !alreadyTaken ) {
          vPt1.push_back(this->vEd() [ iEd1 ]->vPt() [ iPt1 ]);
        }
      }
    }

    std :: vector< Point * > vPt2( sortContainer_( vPt1 ) );
    if ( !superposed(Edge(vPt2 [ 0 ], vPt2 [ 1 ]), * this->vEd() [ 0 ]) ) {
      vPt2.insert( vPt2.begin(), vPt2.back() );
    }

    for ( unsigned int iPt1 = 0; iPt1 < edgeNumber_; ++iPt1 ) {
      this->vPt().push_back(vPt2 [ iPt1 ]);
    }
  }
  ~Polygon() {}

  friend const bool superposed(const ThisT &pl0, const ThisT &pl1)
  {
    int superposedEdgeNumber = 0;
    for ( unsigned int ie0 = 0; ie0 < pl0.vEd().size(); ++ie0 ) {
      for ( unsigned int ie1 = 0; ie1 < pl1.vEd().size(); ++ie1 ) {
        if ( superposed(* pl0.vEd() [ ie0 ], * pl1.vEd() [ ie1 ]) ) {
          ++superposedEdgeNumber;
        }
      }
    }

    return ( superposedEdgeNumber == edgeNumber_ );
  }

  void translate(const std :: vector< Scalar > &dx)
  {
    for ( unsigned int iPt = 0; iPt < verticesNumber_; ++iPt ) {
      this->vPt() [ iPt ].translate(dx);
    }
  }

private:
  template< typename EntityT >
  const std :: vector< EntityT * > sortContainer_(const std :: vector< EntityT * > &vEnt0) const
  {
    /*
     * the following sort strategy is inspired from : http://www.cplusplus.com/articles/NhA0RXSz/
     * Warning: Uses C++11 Features
     */
    Point a(this->pos() [ 0 ] + Scalar(0.1), this->pos() [ 1 ]);
    Point b(this->pos() [ 0 ], this->pos() [ 1 ]);

    std :: vector< EntityAngle< EntityT > > vEntAngle;
    vEntAngle.resize(edgeNumber_);
    for ( unsigned int iEnt1 = 0; iEnt1 < edgeNumber_; ++iEnt1 ) {
      Point c(vEnt0 [ iEnt1 ]->pos() [ 0 ], vEnt0 [ iEnt1 ]->pos() [ 1 ]);
      vEntAngle [ iEnt1 ].entPtr = vEnt0 [ iEnt1 ];
      vEntAngle [ iEnt1 ].angle = angle(a, b, c);
    }

    sort(vEntAngle.begin(), vEntAngle.end(), sortByAngle< EntityT > );

    std :: vector< EntityT * > vEnt1;
    vEnt1.clear();

    for ( unsigned int iEnt1 = 0; iEnt1 < edgeNumber_; ++iEnt1 ) {
#if CLOCKWISE_ROTATION_SENSE == 0
      vEnt1.push_back(vEntAngle [ iEnt1 ].entPtr);
#endif
#if CLOCKWISE_ROTATION_SENSE == 1
      vEnt1.push_back(vEntAngle [ ( edgeNumber_ - iEnt1 - 1 ) ].entPtr);
#endif
    }

    return vEnt1;
  }
};

#endif  /* #ifndef _POLYGON_HH_ */