edge.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 _EDGE_HH_
#define _EDGE_HH_

#include <geometricentity.hh>

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

  typedef msbGrid :: Scalar Scalar;
  typedef msbGrid :: Point Point;
  typedef msbGrid :: Cell Cell;

  enum { dim = msbGrid :: dim };
  static const int verticesNumber_ = 2;

private:
  Scalar eucSize_;

public:

  Edge(Point * p0, Point * p1) : ParentT()
  {
    this->vPt_.clear();
    this->vPt_.push_back(p0);
    this->vPt_.push_back(p1);

    this->vEd_.push_back(this);
    this->vCel_.clear();

    eucSize_ = eucDistance(* p0, * p1);
  }

  ~Edge() {}

  const Scalar &eucSize() const
  { return eucSize_; }

  Scalar &eucSize()
  { return eucSize_; }

  const std :: vector< Scalar > pos() const   /* TODO add primary variable pos_ */
  {
    std :: vector< Scalar > pos0;
    pos0.resize(dim);
    pos0.assign( dim, Scalar(0.0) );

    for ( int iDim = 0; iDim < dim; ++iDim ) {
      for ( int iPt = 0; iPt < this->vPt_.size(); ++iPt ) {
        pos0 [ iDim ] += this->vPt_ [ iPt ]->pos() [ iDim ];
      }
    }

    for ( int iDim = 0; iDim < dim; ++iDim ) {
      pos0 [ iDim ] /= verticesNumber_;
    }

    return pos0;
  }

  const bool has(const Point &p0) const
  {
    return ( superposed(p0, * this->vPt() [ 0 ]) || superposed(p0, * this->vPt() [ 1 ]) );
  }

  const int indexOf(const Point &p0) const
  {
    return superposed(p0, * this->vPt() [ 0 ]) ? 0 :
           superposed(p0, * this->vPt() [ 1 ]) ? 1 : ( -1 );
  }

  friend const bool superposed0(const Edge &e0, const Edge &e1)
  {
    return ( superposed(* e0.vPt() [ 0 ], * e1.vPt() [ 0 ]) && superposed(* e0.vPt() [ 1 ], * e1.vPt() [ 1 ]) );
  }

  friend const bool superposed1(const Edge &e0, const Edge &e1)
  {
    return ( superposed(* e0.vPt() [ 0 ], * e1.vPt() [ 1 ]) && superposed(* e0.vPt() [ 1 ], * e1.vPt() [ 0 ]) );
  }

  friend const bool superposed(const Edge &e0, const Edge &e1)
  {
    return ( superposed0(e0, e1) || superposed1(e0, e1) );
  }

  friend const bool oneSharedPoint(const Edge &e0, const Edge &e1)
  {
    int sharedPointsNumber = 0;
    if ( superposed(* e0.vPt() [ 0 ], * e1.vPt() [ 0 ]) ) {
      ++sharedPointsNumber;
    }

    if ( superposed(* e0.vPt() [ 0 ], * e1.vPt() [ 1 ]) ) {
      ++sharedPointsNumber;
    }

    if ( superposed(* e0.vPt() [ 1 ], * e1.vPt() [ 0 ]) ) {
      ++sharedPointsNumber;
    }

    if ( superposed(* e0.vPt() [ 1 ], * e1.vPt() [ 1 ]) ) {
      ++sharedPointsNumber;
    }

    return ( sharedPointsNumber == 1 );
  }

  /*
   * add the right side neighbor edge of ve1 that exist in ve0
   * Notes :
   * leftSideNeighbor = edge from ve0 sharing with ve1 its first point of its first edge : ve1.front()->vPt()[0]
   * rightSideNeighbor = edge from ve0 sharing with ve1 its last second point of its last edge : ve1.back()->vPt()[1]
   */
  friend bool addLeftSideNeighbor(const std :: vector< Edge * > &ve0, std :: vector< Edge * > &ve1, int &headPointIndex)
  {
    std :: vector< Edge * > neighbors;
    neighbors.clear();
    int newHeadPointIndex = -1;
    for ( int ie0 = 0; ie0 < ve0.size(); ++ie0 ) {
      if ( ve0 [ ie0 ]->has(* ve1.front()->vPt() [ headPointIndex ]) && !superposed( * ve0 [ ie0 ], * ve1.front() ) ) {
        neighbors.push_back(ve0 [ ie0 ]);
        newHeadPointIndex = 1 - ( ve0 [ ie0 ]->indexOf(* ve1.front()->vPt() [ headPointIndex ]) );
      }
    }

    if ( neighbors.size() > 1 ) {
      std :: cerr << "error : neighbors.size() must be 0 or 1 in Edge::addLeftSideNeighbor()\n";
      std :: cerr << "exiting the program by calling : std::exit(1);\n";
      std :: exit(1);
    }

    ve1.insert(ve1.begin(), neighbors [ 0 ]);
    headPointIndex = newHeadPointIndex;
    return ( neighbors.size() == 1 );
  }

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

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

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

    this->vPt() [ 0 ]->infos();
    this->vPt() [ 1 ]->infos();
  }
};

#endif /* _EDGE_HH_ */