point.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 _POINT_HH_
#define _POINT_HH_

#include <cassert>
#include <geometricentity.hh>

class msbGrid :: Point : public msbGrid :: GeometricEntity
{
public:
  typedef msbGrid :: GeometricEntity ParentT;

  typedef msbGrid :: Scalar Scalar;
  typedef msbGrid :: Edge Edge;
  typedef msbGrid :: Cell Cell;

  typedef msbGrid :: Marker Marker;

  enum { dim = msbGrid :: dim };

private:
  std :: vector< Scalar > x_;     /* Coordinates container */

  std :: vector< Point * > vpNeighbor0_;   /*vector of neighbor points in a circle of radius diag*/
  std :: vector< Point * > vpNeighbor1_;   /*vector of neighbor points in a circle of radius diag*/

  /* data for *.m output files */
  Marker marker_;

  /* data for *.geo output files */
  Scalar cl_;       /* Characteristic length */

public:
  Point() : ParentT()
  {
    assert(dim == 2);

    x_.resize(dim);

    this->vPt_.push_back(this);

    marker_.symbol = "'o'";
    marker_.size = 4;
    marker_.edgeColor = Black;
    marker_.faceColor = White;

    cl_ = 1.0;
  }

  Point(const std :: vector< Scalar > & x0) : Point()
  {
    assert(x0.size() >= dim);

    for ( unsigned int iDim = 0; iDim < dim; ++iDim ) {
      x_ [ iDim ] = x0 [ iDim ];
    }
  }

  Point(const Scalar & x, const Scalar & y) : Point()
  {
    x_ [ 0 ] = x;
    x_ [ 1 ] = y;
  }

  ~Point() {}

  const std :: vector< Scalar > &pos() const
  { return x_; }

  const std :: vector< Scalar > &x() const
  { return x_; }

  std :: vector< Scalar > &x()
  { return x_; }

  const std :: vector< Point * > &vpNeighbor0() const
  { return vpNeighbor0_; }

  std :: vector< Point * > &vpNeighbor0()
  { return vpNeighbor0_; }

  const std :: vector< Point * > &vpNeighbor1() const
  { return vpNeighbor1_; }

  std :: vector< Point * > &vpNeighbor1()
  { return vpNeighbor1_; }

  const std :: vector< Point * > onBlockBoundvpNeighbor1() const  /* needed by gridfactory */
  {
    std :: vector< Point * > onBlockBoundNeighbors;
    for ( unsigned int iPt1 = 0; iPt1 < 4; ++iPt1 ) {
      if ( vpNeighbor1_ [ iPt1 ]->onBlockBoundary() ) {
        onBlockBoundNeighbors.push_back(vpNeighbor1_ [ iPt1 ]);
      }
    }

    return onBlockBoundNeighbors;
  }

  const msbGrid :: Marker &marker() const
  { return marker_; }

  msbGrid :: Marker &marker()
  { return marker_; }

  const Scalar &cl() const
  { return cl_; }

  Scalar &cl()
  { return cl_; }

  void translate(const std :: vector< Scalar > &dx)
  {
    for ( int i = 0; i < dim; ++i ) {
      x_ [ i ] += dx [ i ];
    }
  }

  void rotate(const Scalar &_angle, const Point &mc)
  {
    assert(mc.dim == 2);             /* TODO : rotate() must be modified to handle 3D space */

    Scalar angle = deg2Rad(_angle);

    std :: vector< Scalar > dx( dim, Scalar( 0.0 ) );
    for ( int i = 0; i < dim; ++i ) {
      dx [ i ] = x_ [ i ] - mc.x_ [ i ];
    }

    x_ [ 0 ] = std :: cos(angle) * dx [ 0 ] - std :: sin(angle) * dx [ 1 ] + mc.x_ [ 0 ];
    x_ [ 1 ] = std :: sin(angle) * dx [ 0 ] + std :: cos(angle) * dx [ 1 ] + mc.x_ [ 1 ];
  }

  friend const Scalar eucDistance(const Point &pt0, const Point &pt1)       /* Euclidean distance */
  {
    Scalar s = 0;
    for ( int iDim = 0; iDim < dim; ++iDim ) {
      const Scalar dxi = ( pt0.x_ [ iDim ] - pt1.x_ [ iDim ] );
      s += ( dxi * dxi );
    }

    return std :: sqrt(s);
  }

  friend const Scalar angle(const Point &a, const Point &b, const Point &c)
  {
    assert(dim == 2);

    Point ab(b.x() [ 0 ] - a.x() [ 0 ], b.x() [ 1 ] - a.x() [ 1 ]);
    Point cb(b.x() [ 0 ] - c.x() [ 0 ], b.x() [ 1 ] - c.x() [ 1 ]);
    Scalar dot = ( ab.x() [ 0 ] * cb.x() [ 0 ] + ab.x() [ 1 ] * cb.x() [ 1 ] ); /* dot product */
    Scalar cross = ( ab.x() [ 0 ] * cb.x() [ 1 ] - ab.x() [ 1 ] * cb.x() [ 0 ] ); /* cross product */

    return ( atan2(cross, dot) * ( Constants :: _PI / Constants :: PI ) );
  }

  /* return True if the three points a, b and c are colinear */
  friend const bool colinear(const Point &a, const Point &b, const Point &c)
  {
    return ( std :: abs(angle(a, b, c) - 180.0) <= Constants :: TOLERANCE );
  }

  friend const std :: vector< Point * > notMarked(const std :: vector< Point * > &vPt0)
  {
    std :: vector< Point * > vPt1;
    vPt1.clear();
    for ( int iPt = 0; iPt < vPt0.size(); ++iPt ) {
      if ( !vPt0 [ iPt ]->mark() ) {
        vPt1.push_back(vPt0 [ iPt ]);
      }
    }

    return vPt1;
  }

  friend const bool superposed(const Point &pt0, const Point &pt1)
  {
    for ( int iDim = 0; iDim < dim; ++iDim ) {
      if ( !( std :: abs(pt1.x() [ iDim ] - pt0.x() [ iDim ]) <= Constants :: TOLERANCE ) ) {
        return false;
      }
    }

    return true;
  }

  template< typename VEdgePtrT >
  friend const bool pointWith3BoundaryEdges(const VEdgePtrT &vEd0)
  {
    int res = 0;
    for ( int ie = 0; ie < vEd0.size(); ++ie ) {
      if ( vEd0 [ ie ]->onBlockBoundary() ) {
        ++res;
      }
    }

    return ( res == 3 );
  }

  void infos(const std :: string &name0 = "") const
  {
    std :: cout << "# point " << name0 << " ";

    std :: cout << ": (";
    for ( int i = 0; i < dim - 1; ++i ) {
      std :: cout << x_ [ i ] << ", ";
    }

    std :: cout << x_ [ dim - 1 ] << ")";

    std :: cout << " , color = " << colorName( this->color() )
                << " , Id = " << this->Id()
                << " , mark = " << this->mark()
                << " , onBlockBoundary = " << this->onBlockBoundary();

    std :: cout << " , markersize = " << marker_.size
                << " , markerSymbol = " << marker_.symbol
                << " , markerEdgeColor = " << colorName(marker_.edgeColor)
                << " , markerFaceColor = " << colorName(marker_.faceColor) << "\n";
  }
};

#endif  /* #ifndef _POINT_HH_ */