0023948: Wrong intersection between a surface of revolution and a plane.

[occt.git] / src / IntWalk / IntWalk_IWalking_6.gxx

// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef DEB
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#endif


void IntWalk_IWalking::AddPointInCurrentLine
         (const Standard_Integer N,
	  const ThePointOfPath& PathPnt,
	  const Handle(IntWalk_TheIWLine)& CurrentLine) const {


  IntSurf_PntOn2S Psol;
  Psol.SetValue(ThePointOfPathTool::Value3d(PathPnt),
		reversed,wd1[N].ustart,wd1[N].vstart);
  CurrentLine->AddPoint(Psol);
}


void IntWalk_IWalking::MakeWalkingPoint
         (const Standard_Integer Case, 
	  const Standard_Real U, 
	  const Standard_Real V,
	  TheIWFunction& sp,
	  IntSurf_PntOn2S& Psol )

{

// Case == 1      : make a WalkinkPoint.
// Case == 2      : make a WalkinkPoint.
//                  The computation of the tangency on is done  
// Case == 10 + i : make a WalkinkPoint according to i.
//                  but F is updated according to U and V
// Case == other  : the exception Standard_Failure is raised.

  if (Case == 1) 
    Psol.SetValue(sp.Point(),reversed, U, V);
  else if (Case == 2) {
    Psol.SetValue(sp.Point(),reversed, U, V);
  }
  else if (Case == 11 || Case == 12 ) {
    Standard_Real aUV[2], aFF[1], aDD[1][2];
    math_Vector UV(aUV,1, 2);
    math_Vector FF(aFF,1, 1);
    math_Matrix DD(aDD,1, 1, 1, 2); 
    UV(1) = U;
    UV(2) = V;
    sp.Values(UV, FF, DD);
    MakeWalkingPoint(Case - 10, U, V, sp, Psol); 
  }
  else {
    Standard_ConstructionError::Raise();
  }


}



void IntWalk_IWalking::OpenLine(const Standard_Integer N,
                                const IntSurf_PntOn2S& Psol,
				const ThePOPIterator& Pnts1,
				TheIWFunction& sp,
                                const Handle(IntWalk_TheIWLine)& Line )
// **************** open the line and restart in the other direction********

{
  ThePointOfPath PathPnt;

  Standard_Real aUV[2], aFF[1], aDD[1][2];
  math_Vector UV(aUV,1, 2);
  math_Vector FF(aFF,1, 1);
  math_Matrix DD(aDD,1, 1, 1, 2); 

  previousPoint = Line->Value(1);  
  if (!reversed) {
    previousPoint.ParametersOnS2(UV(1),UV(2));
  }
  else {
    previousPoint.ParametersOnS1(UV(1),UV(2));
  }
  sp.Values(UV, FF, DD);
  previousd3d = sp.Direction3d();
  previousd2d = sp.Direction2d();

  if (N>0) { //departure point given at input
    PathPnt = Pnts1.Value(N);
    //mark the line as open with a given stop point
    Line->AddStatusFirst(Standard_False,Standard_True,N,PathPnt); 


    AddPointInCurrentLine(N,PathPnt,Line);

  }
  else  {
    if (N <0) Line->AddPoint(Psol);                      
    Line->AddStatusFirst(Standard_False,Standard_False);
       //mark the line as open without given stop point 
  }
  Line->Reverse();  //inverser la ligne        
  Line->SetTangentVector(previousd3d.Reversed(),Line->NbPoints());
}