//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
//
//  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
//  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License.
//
//  This library 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
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

//  SMESH SMESH : implementaion of SMESH idl descriptions
// File      : StdMeshers_Projection_2D.cxx
// Module    : SMESH
// Created   : Fri Oct 20 11:37:07 2006
// Author    : Edward AGAPOV (eap)
//
#include "StdMeshers_Projection_2D.hxx"

#include "StdMeshers_ProjectionSource2D.hxx"
#include "StdMeshers_ProjectionUtils.hxx"

#include "SMESHDS_Hypothesis.hxx"
#include "SMESHDS_SubMesh.hxx"
#include "SMESH_Block.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Mesh.hxx"
#include "SMESH_MesherHelper.hxx"
#include "SMESH_Pattern.hxx"
#include "SMESH_subMesh.hxx"
#include "SMESH_subMeshEventListener.hxx"
#include "SMESH_Comment.hxx"
#include "SMDS_EdgePosition.hxx"

#include "utilities.h"

#include <BRep_Tool.hxx>
#include <Bnd_B2d.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopoDS.hxx>
#include <gp_Ax2.hxx>
#include <gp_Ax3.hxx>


using namespace std;

#define RETURN_BAD_RESULT(msg) { MESSAGE(")-: Error: " << msg); return false; }

typedef StdMeshers_ProjectionUtils TAssocTool;

//=======================================================================
//function : StdMeshers_Projection_2D
//purpose  : 
//=======================================================================

StdMeshers_Projection_2D::StdMeshers_Projection_2D(int hypId, int studyId, SMESH_Gen* gen)
  :SMESH_2D_Algo(hypId, studyId, gen)
{
  _name = "Projection_2D";
  _shapeType = (1 << TopAbs_FACE);      // 1 bit per shape type

  _compatibleHypothesis.push_back("ProjectionSource2D");
  _sourceHypo = 0;
}

//================================================================================
/*!
 * \brief Destructor
 */
//================================================================================

StdMeshers_Projection_2D::~StdMeshers_Projection_2D()
{}

//=======================================================================
//function : CheckHypothesis
//purpose  : 
//=======================================================================

bool StdMeshers_Projection_2D::CheckHypothesis(SMESH_Mesh&                          theMesh,
                                               const TopoDS_Shape&                  theShape,
                                               SMESH_Hypothesis::Hypothesis_Status& theStatus)
{
  list <const SMESHDS_Hypothesis * >::const_iterator itl;

  const list <const SMESHDS_Hypothesis * >&hyps = GetUsedHypothesis(theMesh, theShape);
  if ( hyps.size() == 0 )
  {
    theStatus = HYP_MISSING;
    return false;  // can't work with no hypothesis
  }

  if ( hyps.size() > 1 )
  {
    theStatus = HYP_ALREADY_EXIST;
    return false;
  }

  const SMESHDS_Hypothesis *theHyp = hyps.front();

  string hypName = theHyp->GetName();

  theStatus = HYP_OK;

  if (hypName == "ProjectionSource2D")
  {
    _sourceHypo = static_cast<const StdMeshers_ProjectionSource2D *>(theHyp);

    // Check hypo parameters

    SMESH_Mesh* srcMesh = _sourceHypo->GetSourceMesh();
    SMESH_Mesh* tgtMesh = & theMesh;
    if ( !srcMesh )
      srcMesh = tgtMesh;

    // check vertices
    if ( _sourceHypo->HasVertexAssociation() )
    {
      // source vertices
      TopoDS_Shape edge = TAssocTool::GetEdgeByVertices
        ( srcMesh, _sourceHypo->GetSourceVertex(1), _sourceHypo->GetSourceVertex(2) );
      if ( edge.IsNull() ||
           !SMESH_MesherHelper::IsSubShape( edge, srcMesh ) ||
           !SMESH_MesherHelper::IsSubShape( edge, _sourceHypo->GetSourceFace() ))
      {
        theStatus = HYP_BAD_PARAMETER;
        SCRUTE((edge.IsNull()));
        SCRUTE((SMESH_MesherHelper::IsSubShape( edge, srcMesh )));
        SCRUTE((SMESH_MesherHelper::IsSubShape( edge, _sourceHypo->GetSourceFace() )));
      }
      else
      {
        // target vertices
        edge = TAssocTool::GetEdgeByVertices
          ( tgtMesh, _sourceHypo->GetTargetVertex(1), _sourceHypo->GetTargetVertex(2) );
        if ( edge.IsNull() || !SMESH_MesherHelper::IsSubShape( edge, tgtMesh ))
        {
          theStatus = HYP_BAD_PARAMETER;
          SCRUTE((edge.IsNull()));
          SCRUTE((SMESH_MesherHelper::IsSubShape( edge, tgtMesh )));
        }
        // PAL16203
        else if ( !_sourceHypo->IsCompoundSource() &&
                  !SMESH_MesherHelper::IsSubShape( edge, theShape ))
        {
          theStatus = HYP_BAD_PARAMETER;
          SCRUTE((SMESH_MesherHelper::IsSubShape( edge, theShape )));
        }
      }
    }
    // check a source face
    if ( !SMESH_MesherHelper::IsSubShape( _sourceHypo->GetSourceFace(), srcMesh ) ||
         ( srcMesh == tgtMesh && theShape == _sourceHypo->GetSourceFace() ))
    {
      theStatus = HYP_BAD_PARAMETER;
      SCRUTE((SMESH_MesherHelper::IsSubShape( _sourceHypo->GetSourceFace(), srcMesh )));
      SCRUTE((srcMesh == tgtMesh));
      SCRUTE(( theShape == _sourceHypo->GetSourceFace() ));
    }
  }
  else
  {
    theStatus = HYP_INCOMPATIBLE;
  }
  return ( theStatus == HYP_OK );
}

namespace {

  //================================================================================
  /*!
   * \brief define if a node is new or old
   * \param node - node to check
   * \retval bool - true if the node existed before Compute() is called
   */
  //================================================================================

  bool isOldNode( const SMDS_MeshNode* node )
  {
    // old nodes are shared by edges and new ones are shared
    // only by faces created by mapper
    SMDS_ElemIteratorPtr invEdge = node->GetInverseElementIterator(SMDSAbs_Edge);
    bool isOld = invEdge->more();
    return isOld;
  }

  //================================================================================
  /*!
   * \brief Class to remove mesh built by pattern mapper on edges
   * and vertices in the case of failure of projection algo.
   * It does it's job at destruction
   */
  //================================================================================

  class MeshCleaner {
    SMESH_subMesh* sm;
  public:
    MeshCleaner( SMESH_subMesh* faceSubMesh ): sm(faceSubMesh) {}
    ~MeshCleaner() { Clean(sm); }
    void Release() { sm = 0; } // mesh will not be removed
    static void Clean( SMESH_subMesh* sm, bool withSub=true )
    {
      if ( !sm ) return;
      // PAL16567, 18920. Remove face nodes as well
//       switch ( sm->GetSubShape().ShapeType() ) {
//       case TopAbs_VERTEX:
//       case TopAbs_EDGE: {
        SMDS_NodeIteratorPtr nIt = sm->GetSubMeshDS()->GetNodes();
        SMESHDS_Mesh* mesh = sm->GetFather()->GetMeshDS();
        while ( nIt->more() ) {
          const SMDS_MeshNode* node = nIt->next();
          if ( !isOldNode( node ) )
            mesh->RemoveNode( node );
        }
        // do not break but iterate over DependsOn()
//       }
//       default:
        if ( !withSub ) return;
        SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false);
        while ( smIt->more() )
          Clean( smIt->next(), false );
//       }
    }
  };

  //================================================================================
  /*!
   * \brief find new nodes belonging to one free border of mesh on face
    * \param sm - submesh on edge or vertex containg nodes to choose from
    * \param face - the face bound the submesh
    * \param u2nodes - map to fill with nodes
    * \param seamNodes - set of found nodes
    * \retval bool - is a success
   */
  //================================================================================

  bool getBoundaryNodes ( SMESH_subMesh*                        sm,
                          const TopoDS_Face&                    face,
                          map< double, const SMDS_MeshNode* > & u2nodes,
                          set< const SMDS_MeshNode* > &         seamNodes)
  {
    u2nodes.clear();
    seamNodes.clear();
    if ( !sm || !sm->GetSubMeshDS() )
      RETURN_BAD_RESULT("Null submesh");

    SMDS_NodeIteratorPtr nIt = sm->GetSubMeshDS()->GetNodes();
    switch ( sm->GetSubShape().ShapeType() ) {

    case TopAbs_VERTEX: {
      while ( nIt->more() ) {
        const SMDS_MeshNode* node = nIt->next();
        if ( isOldNode( node ) ) continue;
        u2nodes.insert( make_pair( 0., node ));
        seamNodes.insert( node );
        return true;
      }
      break;
    }
    case TopAbs_EDGE: {
      
      // Get submeshes of sub-vertices
      const map< int, SMESH_subMesh * >& subSM = sm->DependsOn();
      if ( subSM.size() != 2 )
        RETURN_BAD_RESULT("there must be 2 submeshes of sub-vertices"
                          " but we have " << subSM.size());
      SMESH_subMesh* smV1 = subSM.begin()->second;
      SMESH_subMesh* smV2 = subSM.rbegin()->second;
      if ( !smV1->IsMeshComputed() || !smV2->IsMeshComputed() )
        RETURN_BAD_RESULT("Empty vertex submeshes");

      // Look for a new node on V1
      nIt = smV1->GetSubMeshDS()->GetNodes();
      const SMDS_MeshNode* nV1 = 0;
      while ( nIt->more() && !nV1 ) {
        const SMDS_MeshNode* node = nIt->next();
        if ( !isOldNode( node ) ) nV1 = node;
      }
      if ( !nV1 )
        RETURN_BAD_RESULT("No new node found on V1");

      // Find a new node connected to nV1 and belonging to edge submesh;
      const SMDS_MeshNode* nE = 0;
      SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();
      SMDS_ElemIteratorPtr vElems = nV1->GetInverseElementIterator(SMDSAbs_Face);
      while ( vElems->more() && !nE ) {
        const SMDS_MeshElement* elem = vElems->next();
        int nbNodes = elem->NbNodes();
        if ( elem->IsQuadratic() )
          nbNodes /= 2;
        int iV1 = elem->GetNodeIndex( nV1 );
        // try next after nV1
        int iE = SMESH_MesherHelper::WrapIndex( iV1 + 1, nbNodes );
        if ( smDS->Contains( elem->GetNode( iE ) ))
          nE = elem->GetNode( iE );
        if ( !nE ) {
          // try node before nV1
          iE = SMESH_MesherHelper::WrapIndex( iV1 - 1, nbNodes );
          if ( smDS->Contains( elem->GetNode( iE )))
            nE = elem->GetNode( iE );
        }
        if ( nE && elem->IsQuadratic() ) { // find medium node between nV1 and nE
          if ( Abs( iV1 - iE ) == 1 )
            nE = elem->GetNode( Min ( iV1, iE ) + nbNodes );
          else
            nE = elem->GetNode( elem->NbNodes() - 1 );
        }
      }
      if ( !nE )
        RETURN_BAD_RESULT("new node on edge not found");

      // Get the whole free border of a face
      list< const SMDS_MeshNode* > bordNodes;
      list< const SMDS_MeshElement* > bordFaces;
      if ( !SMESH_MeshEditor::FindFreeBorder (nV1, nE, nV1, bordNodes, bordFaces ))
        RETURN_BAD_RESULT("free border of a face not found by nodes " <<
                          nV1->GetID() << " " << nE->GetID() );

      // Insert nodes of the free border to the map until node on V2 encountered
      SMESHDS_SubMesh* v2smDS = smV2->GetSubMeshDS();
      list< const SMDS_MeshNode* >::iterator bordIt = bordNodes.begin();
      bordIt++; // skip nV1
      for ( ; bordIt != bordNodes.end(); ++bordIt ) {
        const SMDS_MeshNode* node = *bordIt;
        if ( v2smDS->Contains( node ))
          break;
        if ( node->GetPosition()->GetTypeOfPosition() != SMDS_TOP_EDGE )
          RETURN_BAD_RESULT("Bad node position type: node " << node->GetID() <<
                            " pos type " << node->GetPosition()->GetTypeOfPosition());
        const SMDS_EdgePosition* pos =
          static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
        u2nodes.insert( make_pair( pos->GetUParameter(), node ));
        seamNodes.insert( node );
      }
      if ( u2nodes.size() != seamNodes.size() )
        RETURN_BAD_RESULT("Bad node params on edge " << sm->GetId() <<
                          ", " << u2nodes.size() << " != " << seamNodes.size() );
      return true;
    }
    default:;
    }
    RETURN_BAD_RESULT ("Unexpected submesh type");

  } // bool getBoundaryNodes()

  //================================================================================
  /*!
   * \brief Preform projection in case if tgtFace.IsPartner( srcFace ) and in case
   * if projection by transformation is possible
   *  \param tgtFace - target face
   *  \param srcFace - source face
   *  \param tgtMesh - target mesh
   *  \param srcMesh - source mesh
   *  \retval bool - true if succeeded
   */
  //================================================================================

  bool projectPartner(const TopoDS_Face&                tgtFace,
                      const TopoDS_Face&                srcFace,
                      SMESH_Mesh *                      tgtMesh,
                      SMESH_Mesh *                      srcMesh,
                      const TAssocTool::TShapeShapeMap& shape2ShapeMap)
  {
    const double tol = 1e-6;

    gp_Trsf trsf; // transformation to get location of target nodes from source ones
    if ( tgtFace.IsPartner( srcFace ))
    {
      gp_Trsf srcTrsf = srcFace.Location();
      gp_Trsf tgtTrsf = tgtFace.Location();
      trsf = srcTrsf.Inverted() * tgtTrsf;
    }
    else
    {
      // Try to find the transformation

      // make any local coord systems of src and tgt faces
      vector<gp_Pnt> srcPP, tgtPP; // 3 points on face boundaries to make axes of CS
      SMESH_subMesh * srcSM = srcMesh->GetSubMesh( srcFace );
      SMESH_subMeshIteratorPtr smIt = srcSM->getDependsOnIterator(/*includeSelf=*/false,false);
      srcSM = smIt->next(); // sm of a vertex
      while ( smIt->more() && srcPP.size() < 3 )
      {
        srcSM = smIt->next();
        SMESHDS_SubMesh* srcSmds = srcSM->GetSubMeshDS();
        if ( !srcSmds ) continue;
        SMDS_NodeIteratorPtr nIt = srcSmds->GetNodes();
        while ( nIt->more() )
        {
          SMESH_MeshEditor::TNodeXYZ p ( nIt->next());
          bool pOK = false;
          switch ( srcPP.size() )
          {
          case 0: pOK = true; break;

          case 1: pOK = ( srcPP[0].SquareDistance( p ) > tol ); break;
            
          case 2:
            {
              gp_Vec p0p1( srcPP[0], srcPP[1] ), p0p( srcPP[0], p );
              pOK = !p0p1.IsParallel( p0p, tol );
              break;
            }
          }
          if ( !pOK )
            continue;

          // find corresponding point on target shape
          pOK = false;
          gp_Pnt tgtP;
          const TopoDS_Shape& tgtShape = shape2ShapeMap( srcSM->GetSubShape() );
          if ( tgtShape.ShapeType() == TopAbs_VERTEX )
          {
            tgtP = BRep_Tool::Pnt( TopoDS::Vertex( tgtShape ));
            pOK = true;
            //cout << "V - nS " << p._node->GetID() << " - nT " << SMESH_Algo::VertexNode(TopoDS::Vertex( tgtShape),tgtMesh->GetMeshDS())->GetID() << endl;
          }
          else if ( tgtPP.size() > 0 )
          {
            if ( SMESHDS_SubMesh* tgtSmds = tgtMesh->GetMeshDS()->MeshElements( tgtShape ))
            {
              double srcDist = srcPP[0].Distance( p );
              double eTol = BRep_Tool::Tolerance( TopoDS::Edge( tgtShape ));
              SMDS_NodeIteratorPtr nItT = tgtSmds->GetNodes();
              while ( nItT->more() && !pOK )
              {
                const SMDS_MeshNode* n = nItT->next();
                tgtP = SMESH_MeshEditor::TNodeXYZ( n );
                pOK = ( fabs( srcDist - tgtPP[0].Distance( tgtP )) < 2*eTol );
                //cout << "E - nS " << p._node->GetID() << " - nT " << n->GetID()<< " OK - " << pOK<< " " << fabs( srcDist - tgtPP[0].Distance( tgtP ))<< " tol " << eTol<< endl;
              }
            }
          }
          if ( !pOK )
            continue;

          srcPP.push_back( p );
          tgtPP.push_back( tgtP );
        }
      }
      if ( srcPP.size() != 3 )
        return false;

      // make transformation
      gp_Trsf fromTgtCS, toSrcCS; // from/to global CS
      gp_Ax2 srcCS( srcPP[0], gp_Vec( srcPP[0], srcPP[1] ), gp_Vec( srcPP[0], srcPP[2]));
      gp_Ax2 tgtCS( tgtPP[0], gp_Vec( tgtPP[0], tgtPP[1] ), gp_Vec( tgtPP[0], tgtPP[2]));
      toSrcCS  .SetTransformation( gp_Ax3( srcCS ));
      fromTgtCS.SetTransformation( gp_Ax3( tgtCS ));
      fromTgtCS.Invert();

      trsf = fromTgtCS * toSrcCS;
    }

    // Fill map of src to tgt nodes with nodes on edges

    map<const SMDS_MeshNode* , const SMDS_MeshNode*> src2tgtNodes;
    map<const SMDS_MeshNode* , const SMDS_MeshNode*>::iterator srcN_tgtN;

    for ( TopExp_Explorer srcEdge( srcFace, TopAbs_EDGE); srcEdge.More(); srcEdge.Next() )
    {
      const TopoDS_Shape& tgtEdge = shape2ShapeMap( srcEdge.Current() );

      map< double, const SMDS_MeshNode* > srcNodes, tgtNodes;
      if ( !SMESH_Algo::GetSortedNodesOnEdge( srcMesh->GetMeshDS(),
                                              TopoDS::Edge( srcEdge.Current() ),
                                              /*ignoreMediumNodes = */true,
                                              srcNodes )
           ||
           !SMESH_Algo::GetSortedNodesOnEdge( tgtMesh->GetMeshDS(),
                                              TopoDS::Edge( tgtEdge ),
                                              /*ignoreMediumNodes = */true,
                                              tgtNodes )
           ||
           srcNodes.size() != tgtNodes.size())
        return false;

      if ( !tgtEdge.IsPartner( srcEdge.Current() ))
      {
        // check that transormation is OK by three nodes
        gp_Pnt p0S = SMESH_MeshEditor::TNodeXYZ( (srcNodes.begin())  ->second);
        gp_Pnt p1S = SMESH_MeshEditor::TNodeXYZ( (srcNodes.rbegin()) ->second);
        gp_Pnt p2S = SMESH_MeshEditor::TNodeXYZ( (++srcNodes.begin())->second);

        gp_Pnt p0T = SMESH_MeshEditor::TNodeXYZ( (tgtNodes.begin())  ->second);
        gp_Pnt p1T = SMESH_MeshEditor::TNodeXYZ( (tgtNodes.rbegin()) ->second);
        gp_Pnt p2T = SMESH_MeshEditor::TNodeXYZ( (++tgtNodes.begin())->second);

        // transform source points, they must coinside with target ones
        if ( p0T.SquareDistance( p0S.Transformed( trsf )) > tol ||
             p1T.SquareDistance( p1S.Transformed( trsf )) > tol ||
             p2T.SquareDistance( p2S.Transformed( trsf )) > tol )
        {
          //cout << "KO trsf, 3 dist: "
          //<< p0T.SquareDistance( p0S.Transformed( trsf ))<< ", "
          //<< p1T.SquareDistance( p1S.Transformed( trsf ))<< ", "
          //<< p2T.SquareDistance( p2S.Transformed( trsf ))<< ", "<<endl;
          return false;
        }
      }

      map< double, const SMDS_MeshNode* >::iterator u_tn = tgtNodes.begin();
      map< double, const SMDS_MeshNode* >::iterator u_sn = srcNodes.begin();
      for ( ; u_tn != tgtNodes.end(); ++u_tn, ++u_sn)
        src2tgtNodes.insert( make_pair( u_sn->second, u_tn->second ));
    }

    // Make new faces

    // prepare the helper adding quadratic elements if necessary
    SMESH_MesherHelper helper( *tgtMesh );
    helper.IsQuadraticSubMesh( tgtFace );
    helper.SetElementsOnShape( true );

    const SMDS_MeshNode* nullNode = 0;

    SMESHDS_SubMesh* srcSubDS = srcMesh->GetMeshDS()->MeshElements( srcFace );
    SMDS_ElemIteratorPtr elemIt = srcSubDS->GetElements();
    while ( elemIt->more() ) // loop on all mesh faces on srcFace
    {
      const SMDS_MeshElement* elem = elemIt->next();
      vector< const SMDS_MeshNode* > tgtFaceNodes;
      tgtFaceNodes.reserve( elem->NbNodes() );
      SMDS_ElemIteratorPtr nodeIt = elem->nodesIterator();
      while ( nodeIt->more() ) // loop on nodes of the source element
      {
        const SMDS_MeshNode* srcNode = (const SMDS_MeshNode*) nodeIt->next();
        srcN_tgtN = src2tgtNodes.insert( make_pair( srcNode, nullNode )).first;
        if ( srcN_tgtN->second == nullNode )
        {
          // create a new node
          gp_Pnt tgtP = gp_Pnt(srcNode->X(),srcNode->Y(),srcNode->Z()).Transformed( trsf );
          srcN_tgtN->second = helper.AddNode( tgtP.X(), tgtP.Y(), tgtP.Z() );
        }
        tgtFaceNodes.push_back( srcN_tgtN->second );
      }
      // create a new face (with reversed orientation)
      if ( tgtFaceNodes.size() == 3 )
        helper.AddFace( tgtFaceNodes[0],tgtFaceNodes[2],tgtFaceNodes[1]);
      else
        helper.AddFace( tgtFaceNodes[0],tgtFaceNodes[3],tgtFaceNodes[2],tgtFaceNodes[1]);
    }
    return true;
  }

} // namespace


//=======================================================================
//function : Compute
//purpose  : 
//=======================================================================

bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theShape)
{
  if ( !_sourceHypo )
    return false;

  SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
  SMESH_Mesh * tgtMesh = & theMesh;
  if ( !srcMesh )
    srcMesh = tgtMesh;

  SMESHDS_Mesh * meshDS = theMesh.GetMeshDS();

  // ---------------------------
  // Make subshapes association
  // ---------------------------

  TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
  TopoDS_Shape srcShape = _sourceHypo->GetSourceFace().Oriented(TopAbs_FORWARD);

  TAssocTool::TShapeShapeMap shape2ShapeMap;
  TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap, tgtFace );
  if ( !TAssocTool::FindSubShapeAssociation( tgtFace, tgtMesh, srcShape, srcMesh,
                                             shape2ShapeMap)  ||
       !shape2ShapeMap.IsBound( tgtFace ))
    return error(COMPERR_BAD_SHAPE,"Topology of source and target faces seems different" );

  TopoDS_Face srcFace = TopoDS::Face( shape2ShapeMap( tgtFace ).Oriented(TopAbs_FORWARD));

  // ----------------------------------------------
  // Assure that mesh on a source Face is computed
  // ----------------------------------------------

  SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( srcFace );
  SMESH_subMesh* tgtSubMesh = tgtMesh->GetSubMesh( tgtFace );

  if ( tgtMesh == srcMesh ) {
    if ( !TAssocTool::MakeComputed( srcSubMesh ))
      return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed");
  }
  else {
    if ( !srcSubMesh->IsMeshComputed() )
      return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed");
  }

  // try to project from same face with different location
  if ( projectPartner( tgtFace, srcFace, tgtMesh, srcMesh, shape2ShapeMap ))
    return true;

  // --------------------
  // Prepare to mapping 
  // --------------------

  SMESH_MesherHelper helper( theMesh );
  helper.SetSubShape( tgtFace );

  // Check if node projection to a face is needed
  Bnd_B2d uvBox;
  SMDS_ElemIteratorPtr faceIt = srcSubMesh->GetSubMeshDS()->GetElements();
  int nbFaceNodes = 0;
  for ( ; nbFaceNodes < 3 && faceIt->more();  ) {
    const SMDS_MeshElement* face = faceIt->next();
    SMDS_ElemIteratorPtr nodeIt = face->nodesIterator();
    while ( nodeIt->more() ) {
      const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
      if ( node->GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE ) {
        nbFaceNodes++;
        uvBox.Add( helper.GetNodeUV( srcFace, node ));
      }
    }
  }
  const bool toProjectNodes =
    ( nbFaceNodes > 0 && ( uvBox.IsVoid() || uvBox.SquareExtent() < DBL_MIN ));

  // Load pattern from the source face
  SMESH_Pattern mapper;
  mapper.Load( srcMesh, srcFace, toProjectNodes );
  if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
    return error(COMPERR_BAD_INPUT_MESH,"Can't load mesh pattern from the source face");

  // Find the first target vertex corresponding to first vertex of the <mapper>
  // and <theReverse> flag needed to call mapper.Apply()

  TopoDS_Vertex srcV1 = TopoDS::Vertex( mapper.GetSubShape( 1 ));
  if ( srcV1.IsNull() )
    RETURN_BAD_RESULT("Mesh is not bound to the face");
  if ( !shape2ShapeMap.IsBound( srcV1 ))
    RETURN_BAD_RESULT("Not associated vertices, srcV1 " << srcV1.TShape().operator->() );
  TopoDS_Vertex tgtV1 = TopoDS::Vertex( shape2ShapeMap( srcV1 ));

  if ( !SMESH_MesherHelper::IsSubShape( srcV1, srcFace ))
    RETURN_BAD_RESULT("Wrong srcV1 " << srcV1.TShape().operator->());
  if ( !SMESH_MesherHelper::IsSubShape( tgtV1, tgtFace ))
    RETURN_BAD_RESULT("Wrong tgtV1 " << tgtV1.TShape().operator->());

  // try to find out orientation by order of edges
  bool reverse = false;
  list< TopoDS_Edge > tgtEdges, srcEdges;
  list< int > nbEdgesInWires;
  SMESH_Block::GetOrderedEdges( tgtFace, tgtV1, tgtEdges, nbEdgesInWires);
  SMESH_Block::GetOrderedEdges( srcFace, srcV1, srcEdges, nbEdgesInWires);
  if ( nbEdgesInWires.front() > 1 ) // possible to find out
  {
    TopoDS_Edge srcE1 = srcEdges.front(), tgtE1 = tgtEdges.front();
    TopoDS_Shape srcE1bis = shape2ShapeMap( tgtE1 );
    reverse = ( ! srcE1.IsSame( srcE1bis ));
  }
  else if ( nbEdgesInWires.front() == 1 )
  {
    // TODO::Compare orientation of curves in a sole edge
    //RETURN_BAD_RESULT("Not implemented case");
  }
  else
  {
    RETURN_BAD_RESULT("Bad result from SMESH_Block::GetOrderedEdges()");
  }

  // --------------------
  // Perform 2D mapping 
  // --------------------

  // Compute mesh on a target face

  mapper.Apply( tgtFace, tgtV1, reverse );
  if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
    return error("Can't apply source mesh pattern to the face");

  // Create the mesh

  const bool toCreatePolygons = false, toCreatePolyedrs = false;
  mapper.MakeMesh( tgtMesh, toCreatePolygons, toCreatePolyedrs );
  if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
    return error("Can't make mesh by source mesh pattern");

  // it will remove mesh built by pattern mapper on edges and vertices
  // in failure case
  MeshCleaner cleaner( tgtSubMesh );

  // -------------------------------------------------------------------------
  // mapper doesn't take care of nodes already existing on edges and vertices,
  // so we must merge nodes created by it with existing ones 
  // -------------------------------------------------------------------------

  SMESH_MeshEditor editor( tgtMesh );
  SMESH_MeshEditor::TListOfListOfNodes groupsOfNodes;

  // Make groups of nodes to merge

  // loop on edge and vertex submeshes of a target face
  SMESH_subMeshIteratorPtr smIt = tgtSubMesh->getDependsOnIterator(false,false);
  while ( smIt->more() )
  {
    SMESH_subMesh*     sm = smIt->next();
    SMESHDS_SubMesh* smDS = sm->GetSubMeshDS();

    // Sort new and old nodes of a submesh separately

    bool isSeam = helper.IsRealSeam( sm->GetId() );

    enum { NEW_NODES = 0, OLD_NODES };
    map< double, const SMDS_MeshNode* > u2nodesMaps[2], u2nodesOnSeam;
    map< double, const SMDS_MeshNode* >::iterator u_oldNode, u_newNode, u_newOnSeam, newEnd;
    set< const SMDS_MeshNode* > seamNodes;

    // mapper puts on a seam edge nodes from 2 edges
    if ( isSeam && ! getBoundaryNodes ( sm, tgtFace, u2nodesOnSeam, seamNodes ))
      RETURN_BAD_RESULT("getBoundaryNodes() failed");

    SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
    while ( nIt->more() )
    {
      const SMDS_MeshNode* node = nIt->next();
      bool isOld = isOldNode( node );

      if ( !isOld && isSeam ) { // new node on a seam edge
        if ( seamNodes.find( node ) != seamNodes.end())
          continue; // node is already in the map
      }

      // sort nodes on edges by their position
      map< double, const SMDS_MeshNode* > & pos2nodes = u2nodesMaps[isOld ? OLD_NODES : NEW_NODES];
      switch ( node->GetPosition()->GetTypeOfPosition() )
      {
      case  SMDS_TOP_VERTEX: {
        pos2nodes.insert( make_pair( 0, node ));
        break;
      }
      case  SMDS_TOP_EDGE:   {
        const SMDS_EdgePosition* pos =
          static_cast<const SMDS_EdgePosition*>(node->GetPosition().get());
        pos2nodes.insert( make_pair( pos->GetUParameter(), node ));
        break;
      }
      default:
        RETURN_BAD_RESULT("Wrong node position type: "<<
                          node->GetPosition()->GetTypeOfPosition());
      }
    }
    if ( u2nodesMaps[ NEW_NODES ].size() != u2nodesMaps[ OLD_NODES ].size() )
    {
      if ( u2nodesMaps[ NEW_NODES ].size() == 0         &&
           sm->GetSubShape().ShapeType() == TopAbs_EDGE &&
           helper.IsDegenShape( sm->GetId() )             )
        // NPAL15894 (tt88bis.py) - project mesh built by NETGEN_1d_2D that
        // does not make segments/nodes on degenerated edges
        continue;

      RETURN_BAD_RESULT("Different nb of old and new nodes on shape #"<< sm->GetId() <<" "<<
                        u2nodesMaps[ OLD_NODES ].size() << " != " <<
                        u2nodesMaps[ NEW_NODES ].size());
    }
    if ( isSeam && u2nodesMaps[ OLD_NODES ].size() != u2nodesOnSeam.size() ) {
      RETURN_BAD_RESULT("Different nb of old and seam nodes " <<
                        u2nodesMaps[ OLD_NODES ].size() << " != " << u2nodesOnSeam.size());
    }
    // Make groups of nodes to merge
    u_oldNode = u2nodesMaps[ OLD_NODES ].begin(); 
    u_newNode = u2nodesMaps[ NEW_NODES ].begin();
    newEnd    = u2nodesMaps[ NEW_NODES ].end();
    u_newOnSeam = u2nodesOnSeam.begin();
    for ( ; u_newNode != newEnd; ++u_newNode, ++u_oldNode ) {
      groupsOfNodes.push_back( list< const SMDS_MeshNode* >() );
      groupsOfNodes.back().push_back( u_oldNode->second );
      groupsOfNodes.back().push_back( u_newNode->second );
      if ( isSeam )
        groupsOfNodes.back().push_back( (u_newOnSeam++)->second );
    }
  }

  // Merge

  int nbFaceBeforeMerge = tgtSubMesh->GetSubMeshDS()->NbElements();
  editor.MergeNodes( groupsOfNodes );
  int nbFaceAtferMerge = tgtSubMesh->GetSubMeshDS()->NbElements();
  if ( nbFaceBeforeMerge != nbFaceAtferMerge )
    return error(COMPERR_BAD_INPUT_MESH, "Probably invalid node parameters on geom faces");

  // ---------------------------
  // Check elements orientation
  // ---------------------------

  TopoDS_Face face = tgtFace;
  if ( !theMesh.IsMainShape( tgtFace ))
  {
    // find the main shape
    TopoDS_Shape mainShape = meshDS->ShapeToMesh();
    switch ( mainShape.ShapeType() ) {
    case TopAbs_SHELL:
    case TopAbs_SOLID: break;
    default:
      TopTools_ListIteratorOfListOfShape ancestIt = theMesh.GetAncestors( face );
      for ( ; ancestIt.More(); ancestIt.Next() ) {
        TopAbs_ShapeEnum type = ancestIt.Value().ShapeType();
        if ( type == TopAbs_SOLID ) {
          mainShape = ancestIt.Value();
          break;
        } else if ( type == TopAbs_SHELL ) {
          mainShape = ancestIt.Value();
        }
      }
    }
    // find tgtFace in the main solid or shell to know it's true orientation.
    TopExp_Explorer exp( mainShape, TopAbs_FACE );
    for ( ; exp.More(); exp.Next() ) {
      if ( tgtFace.IsSame( exp.Current() )) {
        face = TopoDS::Face( exp.Current() );
        break;
      }
    }
  }
  // Fix orientation
  if ( SMESH_Algo::IsReversedSubMesh( face, meshDS ))
  {
    SMDS_ElemIteratorPtr eIt = meshDS->MeshElements( face )->GetElements();
    while ( eIt->more() ) {
      const SMDS_MeshElement* e = eIt->next();
      if ( e->GetType() == SMDSAbs_Face && !editor.Reorient( e ))
        RETURN_BAD_RESULT("Pb of SMESH_MeshEditor::Reorient()");
    }
  }

  cleaner.Release(); // do not remove mesh

  return true;
}


//=======================================================================
//function : Evaluate
//purpose  : 
//=======================================================================

bool StdMeshers_Projection_2D::Evaluate(SMESH_Mesh& theMesh,
                                        const TopoDS_Shape& theShape,
                                        MapShapeNbElems& aResMap)
{
  if ( !_sourceHypo )
    return false;

  SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh();
  SMESH_Mesh * tgtMesh = & theMesh;
  if ( !srcMesh )
    srcMesh = tgtMesh;

  // ---------------------------
  // Make subshapes association
  // ---------------------------

  TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
  TopoDS_Shape srcShape = _sourceHypo->GetSourceFace().Oriented(TopAbs_FORWARD);

  TAssocTool::TShapeShapeMap shape2ShapeMap;
  TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap, tgtFace );
  if ( !TAssocTool::FindSubShapeAssociation( tgtFace, tgtMesh, srcShape, srcMesh,
                                             shape2ShapeMap)  ||
       !shape2ShapeMap.IsBound( tgtFace ))
    return error(COMPERR_BAD_SHAPE,"Topology of source and target faces seems different" );

  TopoDS_Face srcFace = TopoDS::Face( shape2ShapeMap( tgtFace ).Oriented(TopAbs_FORWARD));

  // ----------------------------------------------
  // Assure that mesh on a source Face is computed
  // ----------------------------------------------

  SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( srcFace );

  if ( !srcSubMesh->IsMeshComputed() )
    return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed");


  std::vector<int> aVec(SMDSEntity_Last);
  for(int i=SMDSEntity_Node; i<SMDSEntity_Last; i++) aVec[i] = 0;

  aVec[SMDSEntity_Node] = srcSubMesh->GetSubMeshDS()->NbNodes();

  //bool quadratic = false;
  SMDS_ElemIteratorPtr elemIt = srcSubMesh->GetSubMeshDS()->GetElements();
  while ( elemIt->more() ) {
    const SMDS_MeshElement* E  = elemIt->next();
    if( E->NbNodes()==3 ) {
      aVec[SMDSEntity_Triangle]++;
    }
    else if( E->NbNodes()==4 ) {
      aVec[SMDSEntity_Quadrangle]++;
    }
    else if( E->NbNodes()==6 && E->IsQuadratic() ) {
      aVec[SMDSEntity_Quad_Triangle]++;
    }
    else if( E->NbNodes()==8 && E->IsQuadratic() ) {
      aVec[SMDSEntity_Quad_Quadrangle]++;
    }
    else {
      aVec[SMDSEntity_Polygon]++;
    }
  }

  SMESH_subMesh * sm = theMesh.GetSubMesh(theShape);
  aResMap.insert(std::make_pair(sm,aVec));

  return true;
}


//=============================================================================
/*!
 * \brief Sets a default event listener to submesh of the source face
  * \param subMesh - submesh where algo is set
 *
 * This method is called when a submesh gets HYP_OK algo_state.
 * After being set, event listener is notified on each event of a submesh.
 * Arranges that CLEAN event is translated from source submesh to
 * the submesh
 */
//=============================================================================

void StdMeshers_Projection_2D::SetEventListener(SMESH_subMesh* subMesh)
{
  TAssocTool::SetEventListener( subMesh,
                                _sourceHypo->GetSourceFace(),
                                _sourceHypo->GetSourceMesh() );
}