Represents a side of a quasi quadrilateral face. More...

#include <StdMeshers_FaceSide.hxx>

Public Member Functions
	StdMeshers_FaceSide (const TopoDS_Face &theFace, const TopoDS_Edge &theEdge, SMESH_Mesh *theMesh, const bool theIsForward, const bool theIgnoreMediumNodes)
	Wrap one edge.
	StdMeshers_FaceSide (const TopoDS_Face &theFace, std::list< TopoDS_Edge > &theEdges, SMESH_Mesh *theMesh, const bool theIsForward, const bool theIgnoreMediumNodes)
	Wrap several edges.
	StdMeshers_FaceSide (const SMDS_MeshNode theNode, const gp_Pnt2d thePnt2d, const StdMeshers_FaceSide theSide)
	Wrap for vertex using data from other FaceSide.
void	Reverse ()
	Change orientation of side geometry.
int	NbPoints () const
	Return nb nodes on edges and vertices (+1 to be == GetUVPtStruct().size() )
int	NbSegments () const
	Return nb edges.
SMESH_Mesh *	GetMesh () const
	Return mesh.
bool	MissVertexNode () const
	Return true if there are vertices without nodes.
const std::vector< UVPtStruct > &	GetUVPtStruct (bool isXConst=0, double constValue=0) const
	Return detailed data on nodes.
const std::vector< UVPtStruct > &	SimulateUVPtStruct (int nbSeg, bool isXConst=0, double constValue=0) const
	Simulates detailed data on nodes.
double	Parameter (double U, TopoDS_Edge &edge) const
	Return edge and parameter on edge by normalized parameter.
gp_Pnt2d	Value2d (double U) const
	Return UV by normalized parameter.
Adaptor2d_Curve2d *	GetCurve2d () const
	Creates a Adaptor2d_Curve2d to be used in SMESH_Block.
BRepAdaptor_CompCurve *	GetCurve3d () const
	Creates a fully functional Adaptor_Curve.
int	NbEdges () const
	Return nb of wrapped edges.
const TopoDS_Edge &	Edge (int i) const
	Return i-th wrapped edge (count starts from zero)
TopoDS_Vertex	FirstVertex (int i=0) const
	Return 1st vertex of the i-the edge (count starts from zero)
TopoDS_Vertex	LastVertex (int i=-1) const
	Return last vertex of the i-the edge (count starts from zero)
double	FirstParameter (int i) const
	Return first normalized parameter of the i-the edge (count starts from zero)
double	LastParameter (int i) const
	Return ast normalized parameter of the i-the edge (count starts from zero)
double	Length () const
	Return side length.
int	EdgeIndex (double U) const
	Return edge index corresponding to normalized parameter.
void	dump (const char *msg=0) const
	Show side features.
Static Public Member Functions
static TSideVector	GetFaceWires (const TopoDS_Face &theFace, SMESH_Mesh &theMesh, const bool theIgnoreMediumNodes, TError &theError)
	Return wires of a face as StdMeshers_FaceSide's.
Protected Attributes
std::vector< uvPtStruct >	myPoints
std::vector< uvPtStruct >	myFalsePoints
std::vector< TopoDS_Edge >	myEdge
std::vector< int >	myEdgeID
std::vector< Handle(Geom2d_Curve)>	myC2d
std::vector< GeomAdaptor_Curve >	myC3dAdaptor
std::vector< double >	myFirst
std::vector< double >	myLast
std::vector< double >	myNormPar
std::vector< double >	myEdgeLength
std::vector< double >	myIsUniform
double	myLength
int	myNbPonits
int	myNbSegments
SMESH_Mesh *	myMesh
bool	myMissingVertexNodes
bool	myIgnoreMediumNodes
gp_Pnt2d	myDefaultPnt2d

Detailed Description

Represents a side of a quasi quadrilateral face.

It can be composed of several edges. Gives access to geometry and 1D mesh of a side.

Definition at line 76 of file StdMeshers_FaceSide.hxx.

Constructor & Destructor Documentation

StdMeshers_FaceSide::StdMeshers_FaceSide	(	const TopoDS_Face &	theFace,
		const TopoDS_Edge &	theEdge,
		SMESH_Mesh *	theMesh,
		const bool	theIsForward,
		const bool	theIgnoreMediumNodes
	)

Wrap one edge.

Constructor of a side of one edge.

Parameters:

theFace	- the face
theEdge	- the edge

Definition at line 65 of file StdMeshers_FaceSide.cxx.

Referenced by GetFaceWires().

{
  list<TopoDS_Edge> edges(1,theEdge);
  *this = StdMeshers_FaceSide( theFace, edges, theMesh, theIsForward, theIgnoreMediumNodes );
}

StdMeshers_FaceSide.StdMeshers_FaceSide	(	const TopoDS_Face &	theFace,
		std::list< TopoDS_Edge > &	theEdges,
		SMESH_Mesh *	theMesh,
		const bool	theIsForward,
		const bool	theIgnoreMediumNodes
	)

Wrap several edges.

Edges must be properly ordered and oriented.

StdMeshers_FaceSide::StdMeshers_FaceSide	(	const SMDS_MeshNode *	theNode,
		const gp_Pnt2d	thePnt2d,
		const StdMeshers_FaceSide *	theSide
	)

Wrap for vertex using data from other FaceSide.

Constructor of a side for vertex using data from other FaceSide.

Parameters:

theVertex	- the vertex
theSide	- the side

Definition at line 199 of file StdMeshers_FaceSide.cxx.

References GetMesh(), GetUVPtStruct(), myC2d, myDefaultPnt2d, myLength, myMesh, myNbPonits, myNbSegments, and myPoints.

{
  myC2d.resize(1);
  myLength = 0;
  myMesh = theSide->GetMesh();
  myDefaultPnt2d = thePnt2d;

  myPoints = theSide->GetUVPtStruct();
  myNbPonits = myNbSegments = myPoints.size();
  std::vector<uvPtStruct>::iterator it = myPoints.begin();
  for(; it!=myPoints.end(); it++) {
    (*it).u = thePnt2d.X();
    (*it).v = thePnt2d.Y();
    (*it).y = 0.0;
    (*it).node = theNode;
  }
}

Member Function Documentation

void StdMeshers_FaceSide::dump ( const char * msg = 0 ) const

Show side features.

Definition at line 470 of file StdMeshers_FaceSide.cxx.

References LastVertex(), MESSAGE, myC2d, myEdge, myFalsePoints, myFirst, myLast, myNbPonits, myNormPar, and myPoints.

Referenced by GetUVPtStruct().

{
#ifdef _DEBUG_
  if (msg) MESSAGE ( std::endl << msg );
  MESSAGE_BEGIN ("NB EDGES: "<< myEdge.size() );
  MESSAGE_ADD ( "nbPoints: "<<myNbPonits<<" vecSize: " << myPoints.size()<<" "<<myFalsePoints.size() );
  for ( int i=0; i<myEdge.size(); ++i)
  {
    MESSAGE_ADD ( "\t"<<i+1 );
    MESSAGE_ADD ( "\tEDGE: " );
    if (myEdge[i].IsNull()) {
      MESSAGE_ADD ( "NULL" );
    }
    else {
      TopAbs::Print(myEdge[i].Orientation(),cout)<<" "<<myEdge[i].TShape().operator->()<<endl;
      MESSAGE_ADD ( "\tV1: " << TopExp::FirstVertex( myEdge[i], 1).TShape().operator->()
                 << "  V2: " << TopExp::LastVertex( myEdge[i], 1).TShape().operator->() );
    }
    MESSAGE_ADD ( "\tC2d: ");
    
    if (myC2d[i].IsNull()) {
      MESSAGE_ADD ( "NULL" );
    }
    else {
      MESSAGE_ADD ( myC2d[i].operator->() );
    }
      
    MESSAGE_ADD ( "\tF: "<<myFirst[i]<< " L: "<< myLast[i] );
    MESSAGE_END ( "\tnormPar: "<<myNormPar[i]<<endl );
  }
#endif
}

const TopoDS_Edge& StdMeshers_FaceSide.Edge ( int i ) const

Return i-th wrapped edge (count starts from zero)

Definition at line 168 of file StdMeshers_FaceSide.hxx.

Referenced by StdMeshers_Hexa_3D.Compute().

{ return myEdge[i]; }

int StdMeshers_FaceSide::EdgeIndex ( double U ) const

Return edge index corresponding to normalized parameter.

Parameters:

U	- the parameter

Return values:

int - index

Definition at line 227 of file StdMeshers_FaceSide.hxx.

References myNormPar.

Referenced by GetUVPtStruct(), Parameter(), SimulateUVPtStruct(), and Value2d().

{
  int i = myNormPar.size() - 1;
  while ( i > 0 && U < myNormPar[ i-1 ] ) --i;
  return i;
}

double StdMeshers_FaceSide::FirstParameter ( int i ) const

Return first normalized parameter of the i-the edge (count starts from zero)

Return first normalized parameter of the i-the edge.

Definition at line 257 of file StdMeshers_FaceSide.hxx.

References myNormPar.

{
  return i==0 ? 0. : i<myNormPar.size() ? myNormPar[i-1] : 1.;
}

TopoDS_Vertex StdMeshers_FaceSide::FirstVertex ( int i = 0 ) const

Return 1st vertex of the i-the edge (count starts from zero)

Return 1st vertex of the i-the edge.

Definition at line 654 of file StdMeshers_FaceSide.cxx.

References myEdge, and NbEdges().

Referenced by GetCurve3d().

{
  TopoDS_Vertex v;
  if ( i < NbEdges() )
  {
    v = myEdge[i].Orientation() <= TopAbs_REVERSED ? // FORWARD || REVERSED
        TopExp::FirstVertex( myEdge[i], 1 )        :
        TopoDS::Vertex( TopoDS_Iterator( myEdge[i] ).Value() );
  }
  return v;
}

Adaptor2d_Curve2d * StdMeshers_FaceSide::GetCurve2d ( ) const

Creates a Adaptor2d_Curve2d to be used in SMESH_Block.

Definition at line 519 of file StdMeshers_FaceSide.cxx.

{
  return new Adaptor2dCurve2d( this );
}

BRepAdaptor_CompCurve * StdMeshers_FaceSide::GetCurve3d ( ) const

Creates a fully functional Adaptor_Curve.

Definition at line 530 of file StdMeshers_FaceSide.cxx.

References FirstVertex(), LastVertex(), and myEdge.

{
  if ( myEdge.empty() )
    return 0;

  TopoDS_Wire aWire;
  BRep_Builder aBuilder;
  aBuilder.MakeWire(aWire);
  for ( int i=0; i<myEdge.size(); ++i )
    aBuilder.Add( aWire, myEdge[i] );

  if ( myEdge.size() == 2 && FirstVertex().IsSame( LastVertex() ))
    aWire.Closed(true); // issue 0021141

  return new BRepAdaptor_CompCurve( aWire );
}

TSideVector StdMeshers_FaceSide::GetFaceWires	(	const TopoDS_Face &	theFace,
		SMESH_Mesh &	theMesh,
		const bool	theIgnoreMediumNodes,
		TError &	theError
	)		`[static]`

Return wires of a face as StdMeshers_FaceSide's.

Definition at line 587 of file StdMeshers_FaceSide.cxx.

References COMPERR_BAD_INPUT_MESH, SMESH_Mesh.GetMeshDS(), SMESH_Block.GetOrderedEdges(), StdMeshers_FaceSide(), SMESH_Algo.VertexNode(), and PAL_MESH_043_3D.wire.

{
  TopoDS_Vertex V1;
  list< TopoDS_Edge > edges, internalEdges;
  list< int > nbEdgesInWires;
  int nbWires = SMESH_Block::GetOrderedEdges (theFace, V1, edges, nbEdgesInWires);

  // split list of all edges into separate wires
  TSideVector wires( nbWires );
  list< int >::iterator nbE = nbEdgesInWires.begin();
  list< TopoDS_Edge >::iterator from = edges.begin(), to = from;
  for ( int iW = 0; iW < nbWires; ++iW, ++nbE )
  {
    std::advance( to, *nbE );
    if ( *nbE == 0 ) // Issue 0020676
    {
      --nbWires;
      --iW;
      wires.resize( nbWires );
      continue;
    }
    list< TopoDS_Edge > wireEdges( from, to );
    // assure that there is a node on the first vertex
    // as StdMeshers_FaceSide::GetUVPtStruct() requires
    if ( wireEdges.front().Orientation() != TopAbs_INTERNAL ) // Issue 0020676
    {
      while ( !SMESH_Algo::VertexNode( TopExp::FirstVertex( wireEdges.front(), true),
                                       theMesh.GetMeshDS()))
      {
        wireEdges.splice(wireEdges.end(), wireEdges,
                         wireEdges.begin(), ++wireEdges.begin());
        if ( from->IsSame( wireEdges.front() )) {
          theError = TError
            ( new SMESH_ComputeError(COMPERR_BAD_INPUT_MESH,"No nodes on vertices"));
          return TSideVector(0);
        }
      }
    }
    else if ( *nbE > 1 ) // Issue 0020676 (Face_pb_netgen.brep) - several internal edges in a wire
    {
      internalEdges.splice( internalEdges.end(), wireEdges, ++wireEdges.begin(), wireEdges.end());
    }

    StdMeshers_FaceSide* wire = new StdMeshers_FaceSide( theFace, wireEdges, &theMesh,
                                                         /*isForward=*/true, theIgnoreMediumNodes);
    wires[ iW ] = StdMeshers_FaceSidePtr( wire );
    from = to;
  }
  while ( !internalEdges.empty() )
  {
    StdMeshers_FaceSide* wire = new StdMeshers_FaceSide( theFace, internalEdges.back(), &theMesh,
                                                         /*isForward=*/true, theIgnoreMediumNodes);
    wires.push_back( StdMeshers_FaceSidePtr( wire ));
    internalEdges.pop_back();
  }
  return wires;
}

SMESH_Mesh* StdMeshers_FaceSide.GetMesh ( ) const

Return mesh.

Definition at line 124 of file StdMeshers_FaceSide.hxx.

Referenced by StdMeshers_FaceSide().

{ return myMesh; }

const vector< UVPtStruct > & StdMeshers_FaceSide::GetUVPtStruct	(	bool	isXConst = `0`,
		double	constValue = `0`
	)		const

Return detailed data on nodes.

Return info on nodes on the side.

Parameters:

isXConst	- true if normalized parameter X is constant
constValue	- constant parameter value

Missing nodes are allowed only on internal vertices

Return values:

UVPtStruct* - array of data structures

Definition at line 226 of file StdMeshers_FaceSide.cxx.

References dump(), EdgeIndex(), SMESH_Mesh.GetMeshDS(), SMESHDS_SubMesh.GetNodes(), SMESH_MesherHelper.GetNodeU(), SMDS_MeshNode.GetPosition(), SMDS_MeshElement.getshapeId(), SMDS_EdgePosition.GetUParameter(), SMESH_MeshEditor.IsMedium(), SMESH_MesherHelper.IthVertex(), Length(), SMESHDS_Mesh.MeshElements(), MESSAGE, myC2d, myC3dAdaptor, myEdge, myEdgeID, myEdgeLength, myFirst, myIgnoreMediumNodes, myIsUniform, myLast, myMesh, myNbPonits, myNormPar, myPoints, NbEdges(), SMESHDS_SubMesh.NbNodes(), uvPtStruct.node, ex29_refine.node(), uvPtStruct.normParam, uvPtStruct.param, SMDSAbs_Edge, uvPtStruct.u, uvPtStruct.v, SMESH_Algo.VertexNode(), uvPtStruct.x, and uvPtStruct.y.

Referenced by StdMeshers_FaceSide(), and StdMeshers_Quadrangle_2D.UpdateDegenUV().

{
  if ( myPoints.empty() ) {

    if ( NbEdges() == 0 ) return myPoints;

    SMESHDS_Mesh* meshDS = myMesh->GetMeshDS();
    SMESH_MesherHelper helper(*myMesh);
    bool paramOK;

    // sort nodes of all edges putting them into a map

    map< double, const SMDS_MeshNode*> u2node;
    //int nbOnDegen = 0;
    for ( int i = 0; i < myEdge.size(); ++i )
    {
      // Put 1st vertex node of a current edge
      TopoDS_Vertex VV[2]; // TopExp::FirstVertex() returns NULL for INTERNAL edge
      VV[0] = SMESH_MesherHelper::IthVertex( 0, myEdge[i]);
      VV[1] = SMESH_MesherHelper::IthVertex( 1, myEdge[i]);
      const SMDS_MeshNode* node = SMESH_Algo::VertexNode( VV[0], meshDS );
      double prevNormPar = ( i == 0 ? 0 : myNormPar[ i-1 ]); // normalized param
      if ( node ) { // internal nodes may be missing
        u2node.insert( make_pair( prevNormPar, node ));
      }
      else if ( i == 0 ) {
        MESSAGE(" NO NODE on VERTEX" );
        return myPoints;
      }

      // Put internal nodes
      SMESHDS_SubMesh* sm = meshDS->MeshElements( myEdge[i] );
      if ( !sm ) continue;
      vector< pair< double, const SMDS_MeshNode*> > u2nodeVec;
      u2nodeVec.reserve( sm->NbNodes() );
      SMDS_NodeIteratorPtr nItr = sm->GetNodes();
      double paramSize = myLast[i] - myFirst[i];
      double r = myNormPar[i] - prevNormPar;
      if ( !myIsUniform[i] )
        while ( nItr->more() )
        {
          const SMDS_MeshNode* node = nItr->next();
          if ( myIgnoreMediumNodes && SMESH_MeshEditor::IsMedium( node, SMDSAbs_Edge ))
            continue;
          double u = helper.GetNodeU( myEdge[i], node, 0, &paramOK );
          double aLenU = GCPnts_AbscissaPoint::Length
            ( const_cast<GeomAdaptor_Curve&>( myC3dAdaptor[i]), myFirst[i], u );
          if ( myEdgeLength[i] < aLenU ) // nonregression test "3D_mesh_NETGEN/G6"
          {
            u2nodeVec.clear();
            break;
          }
          double normPar = prevNormPar + r*aLenU/myEdgeLength[i];
          u2nodeVec.push_back( make_pair( normPar, node ));
        }
      nItr = sm->GetNodes();
      if ( u2nodeVec.empty() )
        while ( nItr->more() )
        {
          const SMDS_MeshNode* node = nItr->next();
          if ( myIgnoreMediumNodes && SMESH_MeshEditor::IsMedium( node, SMDSAbs_Edge ))
            continue;
          double u = helper.GetNodeU( myEdge[i], node, 0, &paramOK );

          // paramSize is signed so orientation is taken into account
          double normPar = prevNormPar + r * ( u - myFirst[i] ) / paramSize;
          u2nodeVec.push_back( make_pair( normPar, node ));
        }
      u2node.insert( u2nodeVec.begin(), u2nodeVec.end() );

      // Put 2nd vertex node for a last edge
      if ( i+1 == myEdge.size() ) {
        node = SMESH_Algo::VertexNode( VV[1], meshDS );
        if ( !node ) {
          MESSAGE(" NO NODE on VERTEX" );
          return myPoints;
        }
        u2node.insert( make_pair( 1., node ));
      }
    }
    if ( u2node.size() != myNbPonits ) {
      MESSAGE("Wrong node parameters on edges, u2node.size():"
              <<u2node.size()<<" !=  myNbPonits:"<<myNbPonits);
      return myPoints;
    }

    // fill array of UVPtStruct

    vector<uvPtStruct>* points = const_cast<vector<uvPtStruct>*>( &myPoints );
    points->resize( myNbPonits );

    int EdgeIndex = 0;
    double prevNormPar = 0, paramSize = myNormPar[ EdgeIndex ];
    map< double, const SMDS_MeshNode*>::iterator u_node = u2node.begin();
    for (int i = 0 ; u_node != u2node.end(); ++u_node, ++i ) {
      UVPtStruct & uvPt = (*points)[i];
      uvPt.node = u_node->second;
      uvPt.x = uvPt.y = uvPt.normParam = u_node->first;
      if ( isXConst ) uvPt.x = constValue;
      else            uvPt.y = constValue;
      const SMDS_EdgePosition* epos =
        dynamic_cast<const SMDS_EdgePosition*>(uvPt.node->GetPosition());
      if (( myNormPar[ EdgeIndex ] < uvPt.normParam ) ||
          ( epos && uvPt.node->getshapeId() != myEdgeID[ EdgeIndex ])) // for myMissingVertexNodes
      {
        prevNormPar = myNormPar[ EdgeIndex ];
        ++EdgeIndex;
#ifdef _DEBUG_
        if ( EdgeIndex >= myEdge.size() ) {
          dump("DEBUG");
          MESSAGE ( "WRONg EdgeIndex " << 1+EdgeIndex
                    << " myNormPar.size()="<<myNormPar.size()
                    << " myNormPar["<< EdgeIndex<<"]="<< myNormPar[ EdgeIndex ]
                    << " uvPt.normParam="<<uvPt.normParam );
        }
#endif
        paramSize = myNormPar[ EdgeIndex ] - prevNormPar;
      }
      if ( epos ) {
        uvPt.param = epos->GetUParameter();
      }
      else {
        double r = ( uvPt.normParam - prevNormPar )/ paramSize;
//         uvPt.param = myFirst[EdgeIndex] * ( 1 - r ) + myLast[EdgeIndex] * r;
        uvPt.param = ( r > 0.5 ? myLast[EdgeIndex] : myFirst[EdgeIndex] );
      }
      if ( !myC2d[ EdgeIndex ].IsNull() ) {
        gp_Pnt2d p = myC2d[ EdgeIndex ]->Value( uvPt.param );
        uvPt.u = p.X();
        uvPt.v = p.Y();
      }
      else {
        uvPt.u = uvPt.v = 1e+100;
      }
    }
  }
  return myPoints;
}

double StdMeshers_FaceSide::LastParameter ( int i ) const

Return ast normalized parameter of the i-the edge (count starts from zero)

Return ast normalized parameter of the i-the edge.

Definition at line 268 of file StdMeshers_FaceSide.hxx.

References myNormPar.

{
  return i<myNormPar.size() ? myNormPar[i] : 1;
}

TopoDS_Vertex StdMeshers_FaceSide::LastVertex ( int i = -1 ) const

Return last vertex of the i-the edge (count starts from zero)

Return last vertex of the i-the edge.

Definition at line 672 of file StdMeshers_FaceSide.cxx.

References myEdge, and NbEdges().

Referenced by dump(), and GetCurve3d().

{
  TopoDS_Vertex v;
  if ( i < NbEdges() )
  {
    const TopoDS_Edge& edge = i<0 ? myEdge[ NbEdges() + i ] : myEdge[i];
    if ( edge.Orientation() <= TopAbs_REVERSED ) // FORWARD || REVERSED
      v = TopExp::LastVertex( edge, 1 );
    else
      for ( TopoDS_Iterator vIt( edge ); vIt.More(); vIt.Next() )
        v = TopoDS::Vertex( vIt.Value() );
  }
  return v;
}

double StdMeshers_FaceSide.Length ( ) const

Return side length.

Definition at line 188 of file StdMeshers_FaceSide.hxx.

Referenced by GetUVPtStruct().

{ return myLength; }

bool StdMeshers_FaceSide.MissVertexNode ( ) const

Return true if there are vertices without nodes.

Definition at line 128 of file StdMeshers_FaceSide.hxx.

{ return myMissingVertexNodes; }

int StdMeshers_FaceSide.NbEdges ( ) const

Return nb of wrapped edges.

Definition at line 164 of file StdMeshers_FaceSide.hxx.

Referenced by StdMeshers_Hexa_3D.Compute(), FirstVertex(), GetUVPtStruct(), LastVertex(), and SimulateUVPtStruct().

{ return myEdge.size(); }

int StdMeshers_FaceSide.NbPoints ( ) const

Return nb nodes on edges and vertices (+1 to be == GetUVPtStruct().size() )

Definition at line 116 of file StdMeshers_FaceSide.hxx.

{ return myNbPonits; }

int StdMeshers_FaceSide.NbSegments ( ) const

Return nb edges.

Definition at line 120 of file StdMeshers_FaceSide.hxx.

{ return myNbSegments; }

double StdMeshers_FaceSide::Parameter	(	double	U,
		TopoDS_Edge &	edge
	)		const

Return edge and parameter on edge by normalized parameter.

Parameters:

U	- the parameter

Return values:

double - pameter on a curve

Definition at line 242 of file StdMeshers_FaceSide.hxx.

References EdgeIndex(), myEdge, myFirst, myLast, and myNormPar.

{
  int i = EdgeIndex( U );
  edge = myEdge[ i ];
  double prevU = i ? myNormPar[ i-1 ] : 0;
  double r = ( U - prevU )/ ( myNormPar[ i ] - prevU );
  return myFirst[i] * ( 1 - r ) + myLast[i] * r;
}

void StdMeshers_FaceSide::Reverse ( )

Change orientation of side geometry.

Definition at line 436 of file StdMeshers_FaceSide.cxx.

References myC2d, myC3dAdaptor, myEdge, myEdgeID, myEdgeLength, myFalsePoints, myFirst, myIsUniform, myLast, myNormPar, myPoints, and reverse().

Referenced by ShiftQuad().

{
  int nbEdges = myEdge.size();
  for ( int i = nbEdges-1; i >= 0; --i ) {
    std::swap( myFirst[i], myLast[i] );
    myEdge[i].Reverse();
    if ( i > 0 ) // at the first loop 1. is overwritten
      myNormPar[i] = 1 - myNormPar[i-1];
  }
  if ( nbEdges > 1 ) {
    reverse( myEdge );
    reverse( myEdgeID );
    reverse( myC2d );
    reverse( myC3dAdaptor );
    reverse( myFirst );
    reverse( myLast );
    reverse( myNormPar );
    reverse( myEdgeLength );
    reverse( myIsUniform );
  }
  if ( nbEdges > 0 )
  {
    myNormPar[nbEdges-1]=1.;
    myPoints.clear();
    myFalsePoints.clear();
  }
}

const vector< UVPtStruct > & StdMeshers_FaceSide::SimulateUVPtStruct	(	int	nbSeg,
		bool	isXConst = `0`,
		double	constValue = `0`
	)		const

Simulates detailed data on nodes.

Falsificate info on nodes.

Parameters:

isXConst	- true if normalized parameter X is constant
constValue	- constant parameter value
nbSeg	- nb of segments on the side

Return values:

UVPtStruct* - array of data structures

Definition at line 374 of file StdMeshers_FaceSide.cxx.

References EdgeIndex(), myC2d, myFalsePoints, myFirst, myLast, myNormPar, NbEdges(), uvPtStruct.node, uvPtStruct.normParam, uvPtStruct.param, uvPtStruct.u, uvPtStruct.v, uvPtStruct.x, and uvPtStruct.y.

{
  if ( myFalsePoints.empty() ) {

    if ( NbEdges() == 0 ) return myFalsePoints;

    vector<uvPtStruct>* points = const_cast<vector<uvPtStruct>*>( &myFalsePoints );
    points->resize( nbSeg+1 );

    int EdgeIndex = 0;
    double prevNormPar = 0, paramSize = myNormPar[ EdgeIndex ];
    for (int i = 0 ; i < myFalsePoints.size(); ++i ) {
      double normPar = double(i) / double(nbSeg);
      UVPtStruct & uvPt = (*points)[i];
      uvPt.node = 0;
      uvPt.x = uvPt.y = uvPt.param = uvPt.normParam = normPar;
      if ( isXConst ) uvPt.x = constValue;
      else            uvPt.y = constValue;
      if ( myNormPar[ EdgeIndex ] < normPar ) {
        prevNormPar = myNormPar[ EdgeIndex ];
        ++EdgeIndex;
        paramSize = myNormPar[ EdgeIndex ] - prevNormPar;
      }
      double r = ( normPar - prevNormPar )/ paramSize;
      uvPt.param = myFirst[EdgeIndex] * ( 1 - r ) + myLast[EdgeIndex] * r;
      if ( !myC2d[ EdgeIndex ].IsNull() ) {
        gp_Pnt2d p = myC2d[ EdgeIndex ]->Value( uvPt.param );
        uvPt.u = p.X();
        uvPt.v = p.Y();
      }
      else {
        uvPt.u = uvPt.v = 1e+100;
      }
    }
  }
  return myFalsePoints;
}

gp_Pnt2d StdMeshers_FaceSide::Value2d ( double U ) const

Return UV by normalized parameter.

Return 2D point by normalized parameter.

Parameters:

U	- normalized parameter value

Return values:

gp_Pnt2d - point

Definition at line 556 of file StdMeshers_FaceSide.cxx.

References EdgeIndex(), myC2d, myC3dAdaptor, myDefaultPnt2d, myEdgeLength, myFirst, myIsUniform, myLast, and myNormPar.

{
  if ( !myC2d[0].IsNull() ) {
    int i = EdgeIndex( U );
    double prevU = i ? myNormPar[ i-1 ] : 0;
    double r = ( U - prevU )/ ( myNormPar[ i ] - prevU );

    double par = myFirst[i] * ( 1 - r ) + myLast[i] * r;
    
    // check parametrization of curve
    if( !myIsUniform[i] )
    {
      double aLen3dU = r * myEdgeLength[i] * ( myFirst[i]>myLast[i] ? -1. : 1.);
      GCPnts_AbscissaPoint AbPnt
        ( const_cast<GeomAdaptor_Curve&>( myC3dAdaptor[i]), aLen3dU, myFirst[i] );
      if( AbPnt.IsDone() ) {
        par = AbPnt.Parameter();
      }
    }
    return myC2d[ i ]->Value(par);

  }
  return myDefaultPnt2d;
}