[occt.git] / src / DsgPrs / DsgPrs.cxx

// Copyright (c) 1998-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.

#include <Aspect_TypeOfLine.hxx>
#include <Aspect_TypeOfMarker.hxx>
#include <DsgPrs.hxx>
#include <ElCLib.hxx>
#include <gce_MakeLin.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Line.hxx>
#include <Geom_Surface.hxx>
#include <GeomAPI_ExtremaCurveCurve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <gp_Ax1.hxx>
#include <gp_Circ.hxx>
#include <gp_Dir.hxx>
#include <gp_Elips.hxx>
#include <gp_Pln.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <Graphic3d_ArrayOfPoints.hxx>
#include <Graphic3d_AspectLine3d.hxx>
#include <Graphic3d_AspectMarker3d.hxx>
#include <Graphic3d_Group.hxx>
#include <Precision.hxx>
#include <Prs3d_Arrow.hxx>
#include <Prs3d_ArrowAspect.hxx>
#include <Prs3d_DimensionAspect.hxx>
#include <Prs3d_LineAspect.hxx>
#include <Prs3d_Presentation.hxx>
#include <Prs3d_Root.hxx>
#include <Quantity_Color.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>

void DsgPrs::ComputeSymbol (const Handle(Prs3d_Presentation)& aPresentation,
			    const Handle(Prs3d_DimensionAspect)& LA,
			    const gp_Pnt& pt1,
			    const gp_Pnt& pt2,
			    const gp_Dir& dir1,
			    const gp_Dir& dir2,
			    const DsgPrs_ArrowSide ArrowSide,
			    const Standard_Boolean drawFromCenter) 
{
  Handle(Graphic3d_Group) aGroup = aPresentation->NewGroup();

  Quantity_Color aColor = LA->LineAspect()->Aspect()->Color();
  Handle(Graphic3d_AspectMarker3d) aMarkerAsp = new Graphic3d_AspectMarker3d (Aspect_TOM_O, aColor, 1.0);
  aGroup->SetGroupPrimitivesAspect (LA->LineAspect()->Aspect());

  switch(ArrowSide) {
  case DsgPrs_AS_NONE:
    {
      break;
    }
  case DsgPrs_AS_FIRSTAR:
    {
      Prs3d_Arrow::Draw (aGroup,
		    pt1,
		    dir1,
		    LA->ArrowAspect()->Angle(),
		    LA->ArrowAspect()->Length());  
      break;
    }
  case DsgPrs_AS_LASTAR:
    {

      Prs3d_Arrow::Draw (aGroup,
		    pt2,
		    dir2,
		    LA->ArrowAspect()->Angle(),
		    LA->ArrowAspect()->Length());  
      break;
    }

  case DsgPrs_AS_BOTHAR:
    {
      Prs3d_Arrow::Draw (aGroup,
		    pt1,
		    dir1,
		    LA->ArrowAspect()->Angle(),
		    LA->ArrowAspect()->Length());  
      Prs3d_Arrow::Draw (aGroup,
		    pt2,
		    dir2,
		    LA->ArrowAspect()->Angle(),
		    LA->ArrowAspect()->Length());  

      break;
    }

  case DsgPrs_AS_FIRSTPT:
    {
      if(drawFromCenter)
      {
        Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
        anArrayOfPoints->AddVertex (pt1.X(), pt1.Y(), pt1.Z());
        Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray (anArrayOfPoints);
      }
      break;
    }

  case DsgPrs_AS_LASTPT:
    {
      // On dessine un rond 
      Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
      anArrayOfPoints->AddVertex (pt2.X(), pt2.Y(), pt2.Z());
      Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray (anArrayOfPoints);
      break;
    }

  case DsgPrs_AS_BOTHPT:
    {
      if(drawFromCenter)
      {
        Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints1 = new Graphic3d_ArrayOfPoints (2);
        anArrayOfPoints1->AddVertex (pt1.X(), pt1.Y(), pt1.Z());
        anArrayOfPoints1->AddVertex (pt2.X(), pt2.Y(), pt2.Z());
        aGroup->SetGroupPrimitivesAspect (aMarkerAsp);
        aGroup->AddPrimitiveArray (anArrayOfPoints1);
      }
      break;
    }

  case DsgPrs_AS_FIRSTAR_LASTPT:
    {
      // an Arrow
      Prs3d_Arrow::Draw (aGroup,
                        pt1,
                        dir1,
                        LA->ArrowAspect()->Angle(),
                        LA->ArrowAspect()->Length());
      // a Round
      Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
      anArrayOfPoints->AddVertex (pt2.X(), pt2.Y(), pt2.Z());
      aGroup->SetPrimitivesAspect (aMarkerAsp);
      aGroup->AddPrimitiveArray (anArrayOfPoints);
      break;
    }

  case DsgPrs_AS_FIRSTPT_LASTAR:
    {
      // an Arrow
      Prs3d_Arrow::Draw (aGroup,
                        pt2,
                        dir2,
                        LA->ArrowAspect()->Angle(),
                        LA->ArrowAspect()->Length());

      // a Round
      if (drawFromCenter)
      {
        Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
        anArrayOfPoints->AddVertex (pt1.X(), pt1.Y(), pt1.Z());
        aGroup->SetPrimitivesAspect (aMarkerAsp);
        aGroup->AddPrimitiveArray (anArrayOfPoints);
      }
      break;
    }
  }
}


//=======================================================================
//function : ComputePlanarFacesLengthPresentation
//purpose  : 
//=======================================================================

void DsgPrs::ComputePlanarFacesLengthPresentation( const Standard_Real FirstArrowLength,
						   const Standard_Real SecondArrowLength,
						   const gp_Pnt& AttachmentPoint1,
						   const gp_Pnt& AttachmentPoint2,
						   const gp_Dir& DirAttach,
						   const gp_Pnt& OffsetPoint,
						   const gp_Pln& PlaneOfFaces,
						   gp_Pnt &        EndOfArrow1,
						   gp_Pnt &        EndOfArrow2,
						   gp_Dir &        DirOfArrow1 )
{
  gp_Lin FirstLin( AttachmentPoint1, DirAttach );  
  gp_Lin SecondLin( AttachmentPoint2, DirAttach );  
  
  EndOfArrow1 = ElCLib::Value( ElCLib::Parameter( FirstLin, OffsetPoint ), FirstLin );
  EndOfArrow2 = ElCLib::Value( ElCLib::Parameter( SecondLin, OffsetPoint ), SecondLin );
 
  if (EndOfArrow1.SquareDistance( EndOfArrow2 ) > Precision::SquareConfusion()) // not null length
    {
      gp_Dir LengthDir( gp_Vec( EndOfArrow1, EndOfArrow2 ) );
      if ((FirstArrowLength + SecondArrowLength)*(FirstArrowLength + SecondArrowLength) < 
	  EndOfArrow1.SquareDistance( EndOfArrow2 ))
	DirOfArrow1 = -LengthDir;
      else
	DirOfArrow1 = LengthDir;
    }
  else // null length
    DirOfArrow1 = PlaneOfFaces.Axis().Direction();
}

//=======================================================================
//function : ComputeCurvilinearFacesLengthPresentation
//purpose  : 
//=======================================================================

void DsgPrs::ComputeCurvilinearFacesLengthPresentation( const Standard_Real FirstArrowLength,
							const Standard_Real SecondArrowLength,
							const Handle( Geom_Surface )& SecondSurf,
							const gp_Pnt& AttachmentPoint1,
							const gp_Pnt& AttachmentPoint2,
							const gp_Dir& DirAttach,
							gp_Pnt &        EndOfArrow2,
							gp_Dir &        DirOfArrow1,
							Handle( Geom_Curve )& VCurve,
							Handle( Geom_Curve )& UCurve,
							Standard_Real & FirstU,
							Standard_Real & deltaU,
							Standard_Real & FirstV,
							Standard_Real & deltaV )
{
  GeomAPI_ProjectPointOnSurf ProjectorOnSurface;
  GeomAPI_ProjectPointOnCurve ProjectorOnCurve;
  Standard_Real U1, V1, U2, V2;
  Standard_Real LastU, LastV;
  Standard_Real SquareTolerance = Precision::SquareConfusion();

  ProjectorOnSurface.Init( AttachmentPoint1, SecondSurf );
  Standard_Integer Index(1);
  Standard_Real MinDist = RealLast();
  Standard_Real LocalU, LocalV;
  gp_Vec D1U, D1V;
  gp_Dir LocalDir;
  for (Standard_Integer i = 1; i <= ProjectorOnSurface.NbPoints(); i++)
    {
      ProjectorOnSurface.Parameters( i, LocalU, LocalV );

      SecondSurf->D1( LocalU, LocalV, EndOfArrow2, D1U, D1V );
      if (D1U.SquareMagnitude() <= SquareTolerance || D1V.SquareMagnitude() <= SquareTolerance)
	LocalDir = gp_Dir( gp_Vec( AttachmentPoint1, ProjectorOnSurface.Point( i ) ) );
      else
	LocalDir = gp_Dir( D1U ^ D1V );
      if (DirAttach.IsParallel( LocalDir, Precision::Angular() ) && ProjectorOnSurface.Distance( i ) < MinDist)
	{
	  Index = i;
	  MinDist = ProjectorOnSurface.Distance( i );
	}
    }
  EndOfArrow2 = ProjectorOnSurface.Point( Index );
  ProjectorOnSurface.Parameters( Index, U1, V1 );
  
  if ((FirstArrowLength + SecondArrowLength)*(FirstArrowLength + SecondArrowLength) <
      AttachmentPoint1.SquareDistance( EndOfArrow2 ))
    DirOfArrow1 = -DirAttach;
  else
    DirOfArrow1 = DirAttach;

  if (EndOfArrow2.SquareDistance( AttachmentPoint2 ) > Precision::SquareConfusion())
    {
      VCurve = SecondSurf->VIso( V1 );
      ProjectorOnCurve.Init( EndOfArrow2, VCurve );
      FirstU = ProjectorOnCurve.LowerDistanceParameter();

      ProjectorOnSurface.Init( AttachmentPoint2, SecondSurf );
      ProjectorOnSurface.LowerDistanceParameters( U2, V2 );
      UCurve = SecondSurf->UIso( U2 );
      
      ProjectorOnCurve.Init( AttachmentPoint2, UCurve );
      LastV = ProjectorOnCurve.LowerDistanceParameter();

      gp_Pnt Intersection = SecondSurf->Value( U2, V1 );
      ProjectorOnCurve.Init( Intersection, VCurve );
      LastU = ProjectorOnCurve.LowerDistanceParameter();
      ProjectorOnCurve.Init( Intersection, UCurve );
      FirstV = ProjectorOnCurve.LowerDistanceParameter();

      deltaU = LastU - FirstU;
      deltaV = LastV - FirstV;

      if (VCurve->IsPeriodic() && Abs( deltaU ) > VCurve->Period()/2)
	{
	  Standard_Real Sign = (deltaU > 0.0)? -1.0 : 1.0;
	  deltaU = VCurve->Period() - Abs( deltaU );
	  deltaU *= Sign;
	}
      if (UCurve->IsPeriodic() && Abs( deltaV ) > UCurve->Period()/2)
	{
	  Standard_Real Sign = (deltaV > 0.0)? -1.0 : 1.0;
	  deltaV = UCurve->Period() - Abs( deltaV );
	  deltaV *= Sign;
	}
    }
}


//=======================================================================
//function : ComputeFacesAnglePresentation
//purpose  : 
//=======================================================================

void DsgPrs::ComputeFacesAnglePresentation( const Standard_Real ArrowLength,
					    const Standard_Real Value,
					    const gp_Pnt& CenterPoint,
					    const gp_Pnt& AttachmentPoint1,
					    const gp_Pnt& AttachmentPoint2,
					    const gp_Dir& dir1,
					    const gp_Dir& dir2,
					    const gp_Dir& axisdir,
					    const Standard_Boolean isPlane,
					    const gp_Ax1& AxisOfSurf,
					    const gp_Pnt& OffsetPoint,
					    gp_Circ &       AngleCirc,
					    Standard_Real & FirstParAngleCirc,
					    Standard_Real & LastParAngleCirc,
					    gp_Pnt &        EndOfArrow1,
					    gp_Pnt &        EndOfArrow2,
					    gp_Dir &        DirOfArrow1,
					    gp_Dir &        DirOfArrow2,
					    gp_Pnt &        ProjAttachPoint2,
					    gp_Circ &       AttachCirc,
					    Standard_Real & FirstParAttachCirc,
					    Standard_Real & LastParAttachCirc )
{
  if (Value > Precision::Angular() && Abs( M_PI-Value ) > Precision::Angular())
    {
      // Computing presentation of angle's arc
      gp_Ax2 ax( CenterPoint, axisdir, dir1 );
      AngleCirc.SetPosition( ax );
      AngleCirc.SetRadius( CenterPoint.Distance( OffsetPoint ) );
      gp_Vec vec1( dir1 );
      vec1 *= AngleCirc.Radius();
      gp_Pnt p1 = CenterPoint.Translated( vec1 );
      gp_Vec vec2( dir2 );
      vec2 *= AngleCirc.Radius();
      gp_Pnt p2 = CenterPoint.Translated( vec2 );
      
      Standard_Real Par1 = 0.;
      Standard_Real Par2 = ElCLib::Parameter( AngleCirc, p2 );
      Standard_Real Par0 = ElCLib::Parameter( AngleCirc, OffsetPoint );
      
      gp_Vec PosVec( CenterPoint, OffsetPoint );
      gp_Vec NormalOfPlane = vec1 ^ vec2;
      
      gp_Vec Normal1 = NormalOfPlane ^ vec1;
      gp_Vec Normal2 = NormalOfPlane ^ vec2;
      Standard_Integer Sign1 = (PosVec * Normal1 >= 0)? 1 : -1;
      Standard_Integer Sign2 = (PosVec * Normal2 >= 0)? 1 : -1;
      if (Sign1 == 1 && Sign2 == -1)
	{
	  FirstParAngleCirc = Par1;
	  LastParAngleCirc  = Par2;
	}
      else if (Sign1 == 1 && Sign2 == 1)
	{ 
	  FirstParAngleCirc = Par1;
	  LastParAngleCirc  = Par0;
	}
      else if (Sign1 == -1 && Sign2 == 1)
	{
	  Par1 += M_PI;
	  Par2 += M_PI;
	  FirstParAngleCirc = Par1;
	  LastParAngleCirc  = Par2;
	}
      else //Sign1 == -1 && Sign2 == -1
	{
	  AngleCirc.SetPosition( gp_Ax2( CenterPoint, axisdir, gp_Dir( PosVec ) ) );
	  Par0 = 0.;
	  Par1 = ElCLib::Parameter( AngleCirc, p1 );
	  Par2 = ElCLib::Parameter( AngleCirc, p2 );
	  FirstParAngleCirc = Par0;
	  LastParAngleCirc  = Par2;
	}

      // Computing presentation of arrows
      EndOfArrow1 = ElCLib::Value( Par1, AngleCirc );
      EndOfArrow2  = ElCLib::Value( Par2, AngleCirc );
      Standard_Real beta = 0.;
      if (AngleCirc.Radius() > Precision::Confusion())
	beta = ArrowLength / AngleCirc.Radius();
      gp_Pnt OriginOfArrow1 = ElCLib::Value( Par1 + beta, AngleCirc );
      gp_Pnt OriginOfArrow2 = ElCLib::Value( Par2 - beta, AngleCirc );
      DirOfArrow1 = gp_Dir( gp_Vec( OriginOfArrow1, EndOfArrow1 ) );
      DirOfArrow2 = gp_Dir( gp_Vec( OriginOfArrow2, EndOfArrow2 ) );
      if (EndOfArrow1.SquareDistance( EndOfArrow2 ) <= (ArrowLength + ArrowLength)*(ArrowLength + ArrowLength))
	{
	  DirOfArrow1.Reverse();
	  DirOfArrow2.Reverse();
	}
    }
  else // dir1 and dir2 are parallel
    {
      gp_Dir ArrowDir = axisdir ^ dir1;
      DirOfArrow1 = ArrowDir;
      DirOfArrow2 = -ArrowDir;
      gp_Lin DirLine( AttachmentPoint1, dir1 );
      EndOfArrow1 = ElCLib::Value( ElCLib::Parameter( DirLine, OffsetPoint ), DirLine );
      EndOfArrow2 = EndOfArrow1;
    }

  // Line or arc from AttachmentPoint2 to its "projection"
  gp_Lin SecondLin( CenterPoint, dir2 );
  if (SecondLin.Contains( AttachmentPoint2, Precision::Confusion() ))
    ProjAttachPoint2 = AttachmentPoint2;
  else
    {
      if (isPlane)
	ProjAttachPoint2 = ElCLib::Value( ElCLib::Parameter( SecondLin, AttachmentPoint2 ), SecondLin );
      else
	{
	  gp_Lin LineOfAxis( AxisOfSurf );
	  gp_Pnt CenterOfArc = ElCLib::Value( ElCLib::Parameter( LineOfAxis, AttachmentPoint2 ),
					      LineOfAxis );
	  
	  gp_Ax2 Ax2( CenterOfArc,
		      AxisOfSurf.Direction(),
		      gp_Dir( gp_Vec( CenterOfArc, AttachmentPoint2 ) ) );
	  AttachCirc.SetPosition( Ax2 );
	  AttachCirc.SetRadius( CenterOfArc.Distance( AttachmentPoint2 ) );
	  
	  GeomAPI_ExtremaCurveCurve Intersection( new Geom_Circle( AttachCirc ),
						  new Geom_Line( SecondLin ) );
	  Intersection.NearestPoints( ProjAttachPoint2, ProjAttachPoint2 );
	  
	  Standard_Real U2 = ElCLib::Parameter( AttachCirc, ProjAttachPoint2 );
	  if (U2 <= M_PI)
	    {
	      FirstParAttachCirc = 0;
	      LastParAttachCirc  = U2;
	    }
	  else
	    {
	      FirstParAttachCirc = U2;
	      LastParAttachCirc  = 2*M_PI;
	    }
	}
    }
}


void DsgPrs::ComputeFilletRadiusPresentation( const Standard_Real /*ArrowLength*/,
					      const Standard_Real Value,
					      const gp_Pnt &      Position,
					      const gp_Dir &      NormalDir,
					      const gp_Pnt &      FirstPoint,
					      const gp_Pnt &      SecondPoint,
					      const gp_Pnt &      Center,
					      const gp_Pnt &      BasePnt,
					      const Standard_Boolean drawRevers,
					      Standard_Boolean &  SpecCase,
					      gp_Circ &           FilletCirc,
					      Standard_Real &     FirstParCirc,
					      Standard_Real &     LastParCirc,
					      gp_Pnt &            EndOfArrow,
					      gp_Dir &            DirOfArrow,
					      gp_Pnt &            DrawPosition)
{
  gp_Dir dir1(gp_Vec(Center, FirstPoint));
  gp_Dir dir2(gp_Vec(Center, SecondPoint));
  Standard_Real Angle = dir1.Angle(dir2);
  if(Angle <= Precision::Angular() || ( M_PI - Angle ) <= Precision::Angular() ||
     Value <= Precision::Confusion()) SpecCase = Standard_True;
  else SpecCase = Standard_False;
  if ( !SpecCase )
    {
       // Computing presentation of fillet's arc
      gp_Ax2 ax( Center, NormalDir, dir1 );
      FilletCirc.SetPosition( ax );
      FilletCirc.SetRadius( Center.Distance( FirstPoint ) ); //***
      gp_Vec vec1( dir1 );
      vec1 *= FilletCirc.Radius();
      gp_Vec vec2( dir2 );
      vec2 *= FilletCirc.Radius();
      gp_Vec PosVec;
      if(! Center.IsEqual( Position, Precision::Confusion() ))
	PosVec.SetXYZ( gp_Vec(Center, Position).XYZ() );
      else
	PosVec.SetXYZ( (vec1.Added(vec2)).XYZ() );
      gp_Vec NormalOfPlane = vec1 ^ vec2;      
      gp_Vec Normal1 = NormalOfPlane ^ vec1;
      gp_Vec Normal2 = NormalOfPlane ^ vec2;
      Standard_Integer Sign1 = (PosVec * Normal1 >= 0)? 1 : -1;
      Standard_Integer Sign2 = (PosVec * Normal2 >= 0)? 1 : -1;
      gp_Lin L1( Center, dir1 );
      gp_Lin L2( Center, dir2 );
      if ( Sign1 != Sign2 )
	{
	  DrawPosition = Position; //***
	  gp_Dir direction(PosVec) ;
	  Standard_Real angle = dir1.Angle(direction) ;
          if (( dir1 ^ direction) * NormalDir < 0.0e0)   angle = -angle ;
	  if(Sign1 == -1) angle += M_PI;
	  EndOfArrow = ElCLib::Value(angle, FilletCirc); //***
	  	   
	}
      else
	{
	  if(L1.Distance(Position) < L2.Distance(Position))
	      {
		EndOfArrow = FirstPoint; //***
		DrawPosition =	ElCLib::Value(ElCLib::Parameter(L1, Position), L1);	
	      }
	  else
	    {
	      EndOfArrow = SecondPoint; //***
	      DrawPosition = ElCLib::Value(ElCLib::Parameter(L2, Position), L2);
	    }
	}
      if((dir1^dir2).IsOpposite(NormalDir, Precision::Angular()))
	{
	  gp_Dir newdir = NormalDir.Reversed() ;
	  gp_Ax2 axnew( Center, newdir, dir1 );
	  FilletCirc.SetPosition( axnew );
	}
      FirstParCirc = ElCLib::Parameter( FilletCirc, FirstPoint );
      LastParCirc  = ElCLib::Parameter( FilletCirc, SecondPoint );
    }
  else //Angle equal 0 or PI or R = 0
    {
      DrawPosition = Position;
      EndOfArrow   = BasePnt;
    }

  if(drawRevers)
    {
      gp_Vec Vd(DrawPosition, EndOfArrow);
      DrawPosition.Translate(Vd *2);
    }
  DirOfArrow.SetXYZ(gp_Dir(gp_Vec(DrawPosition, EndOfArrow)).XYZ());      
}

//=======================================================================
//function : ComputeRadiusLine
//purpose  : 
//=======================================================================

void DsgPrs::ComputeRadiusLine(const gp_Pnt & aCenter,
			       const gp_Pnt & anEndOfArrow,
			       const gp_Pnt & aPosition,
			       const Standard_Boolean drawFromCenter,
			             gp_Pnt & aRadLineOrign,
			             gp_Pnt & aRadLineEnd)
{
  if(drawFromCenter)
    {
      gp_Lin RadiusLine = gce_MakeLin( aCenter, anEndOfArrow );
      Standard_Real PosParOnLine = ElCLib::Parameter( RadiusLine, aPosition );
      Standard_Real EndOfArrowPar     = ElCLib::Parameter( RadiusLine, anEndOfArrow );
      if (PosParOnLine < 0.0)
	{
	  aRadLineOrign = aPosition;
	  aRadLineEnd   = anEndOfArrow;
	}
      else if (PosParOnLine > EndOfArrowPar)
	{
	  aRadLineOrign = aPosition;
	  aRadLineEnd   = aCenter;
	}
      else
	{
	  aRadLineOrign = aCenter;
	  aRadLineEnd   = anEndOfArrow;
	}
    }
  else
    {
      aRadLineOrign = aPosition;
      aRadLineEnd   = anEndOfArrow;
    }
}


//=======================================================================
//function : DistanceFromApex
//purpose  : 
//=======================================================================

Standard_Real DsgPrs::DistanceFromApex(const gp_Elips & elips,
				       const gp_Pnt   & Apex,
				       const Standard_Real par)
{
  Standard_Real dist;
  Standard_Real parApex = ElCLib::Parameter ( elips, Apex );
  if(parApex == 0.0 || parApex == M_PI) 
    {//Major case
      if(parApex == 0.0) //pos Apex
	dist = (par < M_PI) ? par : (2*M_PI - par);
      else //neg Apex
	dist = (par < M_PI) ? ( M_PI - par) : ( par - M_PI );
    }
  else 
    {// Minor case
      if(parApex == M_PI / 2) //pos Apex
	{
	  if(par <= parApex + M_PI && par > parApex )
	    dist = par - parApex;
	  else 
	    { 
	      if(par >  parApex + M_PI)
		dist = 2*M_PI - par + parApex;
	      else
		dist = parApex - par; // 0 < par < M_PI/2
	    }
	}
      else //neg Apex == 3/2 PI
	{
	  if(par <= parApex && par >= M_PI/2) 
	    dist = parApex - par;
	  else
	    {
	      if(par >  parApex) 
		dist = par - parApex;
	      else
		dist = par + M_PI/2; // 0 < par < PI/2
	    }
	}
    }
  return dist;
}
Commit	Line	Data
b311480e	1	// Copyright (c) 1998-1999 Matra Datavision
973c2be1	2	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	3	//
973c2be1	4	// This file is part of Open CASCADE Technology software library.
b311480e	5	//
d5f74e42	6	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	7	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	8	// by the Free Software Foundation, with special exception defined in the file
	9	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	10	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	11	//
973c2be1	12	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	13	// commercial license or contractual agreement.
b311480e	14
7fd59977	15	#include <Aspect_TypeOfLine.hxx>
7fd59977	16	#include <Aspect_TypeOfMarker.hxx>
42cf5bc1	17	#include <DsgPrs.hxx>
7fd59977	18	#include <ElCLib.hxx>
42cf5bc1	19	#include <gce_MakeLin.hxx>
7fd59977	20	#include <Geom_Circle.hxx>
42cf5bc1	21	#include <Geom_Curve.hxx>
	22	#include <Geom_Line.hxx>
	23	#include <Geom_Surface.hxx>
7fd59977	24	#include <GeomAPI_ExtremaCurveCurve.hxx>
7fd59977	25	#include <GeomAPI_ProjectPointOnCurve.hxx>
42cf5bc1	26	#include <GeomAPI_ProjectPointOnSurf.hxx>
	27	#include <gp_Ax1.hxx>
	28	#include <gp_Circ.hxx>
	29	#include <gp_Dir.hxx>
	30	#include <gp_Elips.hxx>
	31	#include <gp_Pln.hxx>
	32	#include <gp_Pnt.hxx>
	33	#include <gp_Vec.hxx>
	34	#include <Graphic3d_ArrayOfPoints.hxx>
	35	#include <Graphic3d_AspectLine3d.hxx>
	36	#include <Graphic3d_AspectMarker3d.hxx>
	37	#include <Graphic3d_Group.hxx>
42cf5bc1	38	#include <Precision.hxx>
	39	#include <Prs3d_Arrow.hxx>
	40	#include <Prs3d_ArrowAspect.hxx>
	41	#include <Prs3d_DimensionAspect.hxx>
	42	#include <Prs3d_LineAspect.hxx>
	43	#include <Prs3d_Presentation.hxx>
	44	#include <Prs3d_Root.hxx>
	45	#include <Quantity_Color.hxx>
	46	#include <TCollection_AsciiString.hxx>
	47	#include <TCollection_ExtendedString.hxx>
7fd59977	48
7fd59977	49	void DsgPrs::ComputeSymbol (const Handle(Prs3d_Presentation)& aPresentation,
a6eb515f	50	const Handle(Prs3d_DimensionAspect)& LA,
7fd59977	51	const gp_Pnt& pt1,
	52	const gp_Pnt& pt2,
	53	const gp_Dir& dir1,
	54	const gp_Dir& dir2,
a6eb515f	55	const DsgPrs_ArrowSide ArrowSide,
a6eb515f	56	const Standard_Boolean drawFromCenter)
7fd59977	57	{
bf5f0ca2	58	Handle(Graphic3d_Group) aGroup = aPresentation->NewGroup();
a577aaab	59
b6472664	60	Quantity_Color aColor = LA->LineAspect()->Aspect()->Color();
a577aaab	61	Handle(Graphic3d_AspectMarker3d) aMarkerAsp = new Graphic3d_AspectMarker3d (Aspect_TOM_O, aColor, 1.0);
bf5f0ca2	62	aGroup->SetGroupPrimitivesAspect (LA->LineAspect()->Aspect());
7fd59977	63
	64	switch(ArrowSide) {
	65	case DsgPrs_AS_NONE:
	66	{
	67	break;
	68	}
	69	case DsgPrs_AS_FIRSTAR:
	70	{
bf5f0ca2	71	Prs3d_Arrow::Draw (aGroup,
7fd59977	72	pt1,
	73	dir1,
	74	LA->ArrowAspect()->Angle(),
	75	LA->ArrowAspect()->Length());
	76	break;
	77	}
	78	case DsgPrs_AS_LASTAR:
	79	{
	80
bf5f0ca2	81	Prs3d_Arrow::Draw (aGroup,
7fd59977	82	pt2,
	83	dir2,
	84	LA->ArrowAspect()->Angle(),
	85	LA->ArrowAspect()->Length());
	86	break;
	87	}
	88
	89	case DsgPrs_AS_BOTHAR:
	90	{
bf5f0ca2	91	Prs3d_Arrow::Draw (aGroup,
7fd59977	92	pt1,
	93	dir1,
	94	LA->ArrowAspect()->Angle(),
	95	LA->ArrowAspect()->Length());
bf5f0ca2	96	Prs3d_Arrow::Draw (aGroup,
7fd59977	97	pt2,
	98	dir2,
	99	LA->ArrowAspect()->Angle(),
	100	LA->ArrowAspect()->Length());
	101
	102	break;
	103	}
	104
	105	case DsgPrs_AS_FIRSTPT:
	106	{
a6eb515f	107	if(drawFromCenter)
a577aaab	108	{
	109	Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
	110	anArrayOfPoints->AddVertex (pt1.X(), pt1.Y(), pt1.Z());
	111	Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray (anArrayOfPoints);
	112	}
7fd59977	113	break;
	114	}
	115
	116	case DsgPrs_AS_LASTPT:
	117	{
	118	// On dessine un rond
a577aaab	119	Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
	120	anArrayOfPoints->AddVertex (pt2.X(), pt2.Y(), pt2.Z());
	121	Prs3d_Root::CurrentGroup(aPresentation)->AddPrimitiveArray (anArrayOfPoints);
7fd59977	122	break;
	123	}
	124
	125	case DsgPrs_AS_BOTHPT:
	126	{
a6eb515f	127	if(drawFromCenter)
a577aaab	128	{
bf5f0ca2	129	Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints1 = new Graphic3d_ArrayOfPoints (2);
a577aaab	130	anArrayOfPoints1->AddVertex (pt1.X(), pt1.Y(), pt1.Z());
bf5f0ca2	131	anArrayOfPoints1->AddVertex (pt2.X(), pt2.Y(), pt2.Z());
	132	aGroup->SetGroupPrimitivesAspect (aMarkerAsp);
	133	aGroup->AddPrimitiveArray (anArrayOfPoints1);
a6eb515f	134	}
7fd59977	135	break;
	136	}
	137
	138	case DsgPrs_AS_FIRSTAR_LASTPT:
	139	{
	140	// an Arrow
bf5f0ca2	141	Prs3d_Arrow::Draw (aGroup,
a6eb515f	142	pt1,
	143	dir1,
	144	LA->ArrowAspect()->Angle(),
	145	LA->ArrowAspect()->Length());
7fd59977	146	// a Round
a577aaab	147	Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
a577aaab	148	anArrayOfPoints->AddVertex (pt2.X(), pt2.Y(), pt2.Z());
bf5f0ca2	149	aGroup->SetPrimitivesAspect (aMarkerAsp);
bf5f0ca2	150	aGroup->AddPrimitiveArray (anArrayOfPoints);
7fd59977	151	break;
	152	}
	153
	154	case DsgPrs_AS_FIRSTPT_LASTAR:
	155	{
7fd59977	156	// an Arrow
bf5f0ca2	157	Prs3d_Arrow::Draw (aGroup,
a6eb515f	158	pt2,
	159	dir2,
	160	LA->ArrowAspect()->Angle(),
	161	LA->ArrowAspect()->Length());
bf5f0ca2	162
	163	// a Round
	164	if (drawFromCenter)
	165	{
	166	Handle(Graphic3d_ArrayOfPoints) anArrayOfPoints = new Graphic3d_ArrayOfPoints (1);
	167	anArrayOfPoints->AddVertex (pt1.X(), pt1.Y(), pt1.Z());
	168	aGroup->SetPrimitivesAspect (aMarkerAsp);
	169	aGroup->AddPrimitiveArray (anArrayOfPoints);
	170	}
7fd59977	171	break;
	172	}
	173	}
	174	}
	175
	176
	177	//=======================================================================
	178	//function : ComputePlanarFacesLengthPresentation
	179	//purpose :
	180	//=======================================================================
	181
	182	void DsgPrs::ComputePlanarFacesLengthPresentation( const Standard_Real FirstArrowLength,
	183	const Standard_Real SecondArrowLength,
	184	const gp_Pnt& AttachmentPoint1,
	185	const gp_Pnt& AttachmentPoint2,
	186	const gp_Dir& DirAttach,
	187	const gp_Pnt& OffsetPoint,
	188	const gp_Pln& PlaneOfFaces,
	189	gp_Pnt & EndOfArrow1,
	190	gp_Pnt & EndOfArrow2,
	191	gp_Dir & DirOfArrow1 )
	192	{
	193	gp_Lin FirstLin( AttachmentPoint1, DirAttach );
	194	gp_Lin SecondLin( AttachmentPoint2, DirAttach );
	195
	196	EndOfArrow1 = ElCLib::Value( ElCLib::Parameter( FirstLin, OffsetPoint ), FirstLin );
	197	EndOfArrow2 = ElCLib::Value( ElCLib::Parameter( SecondLin, OffsetPoint ), SecondLin );
	198
08cd2f6b	199	if (EndOfArrow1.SquareDistance( EndOfArrow2 ) > Precision::SquareConfusion()) // not null length
7fd59977	200	{
	201	gp_Dir LengthDir( gp_Vec( EndOfArrow1, EndOfArrow2 ) );
	202	if ((FirstArrowLength + SecondArrowLength)*(FirstArrowLength + SecondArrowLength) <
	203	EndOfArrow1.SquareDistance( EndOfArrow2 ))
	204	DirOfArrow1 = -LengthDir;
	205	else
	206	DirOfArrow1 = LengthDir;
	207	}
	208	else // null length
	209	DirOfArrow1 = PlaneOfFaces.Axis().Direction();
	210	}
	211
	212	//=======================================================================
	213	//function : ComputeCurvilinearFacesLengthPresentation
	214	//purpose :
	215	//=======================================================================
	216
	217	void DsgPrs::ComputeCurvilinearFacesLengthPresentation( const Standard_Real FirstArrowLength,
	218	const Standard_Real SecondArrowLength,
	219	const Handle( Geom_Surface )& SecondSurf,
	220	const gp_Pnt& AttachmentPoint1,
	221	const gp_Pnt& AttachmentPoint2,
	222	const gp_Dir& DirAttach,
	223	gp_Pnt & EndOfArrow2,
	224	gp_Dir & DirOfArrow1,
	225	Handle( Geom_Curve )& VCurve,
	226	Handle( Geom_Curve )& UCurve,
	227	Standard_Real & FirstU,
	228	Standard_Real & deltaU,
	229	Standard_Real & FirstV,
	230	Standard_Real & deltaV )
	231	{
	232	GeomAPI_ProjectPointOnSurf ProjectorOnSurface;
	233	GeomAPI_ProjectPointOnCurve ProjectorOnCurve;
ee2be2a8	234	Standard_Real U1, V1, U2, V2;
7fd59977	235	Standard_Real LastU, LastV;
08cd2f6b	236	Standard_Real SquareTolerance = Precision::SquareConfusion();
7fd59977	237
	238	ProjectorOnSurface.Init( AttachmentPoint1, SecondSurf );
	239	Standard_Integer Index(1);
ee2be2a8	240	Standard_Real MinDist = RealLast();
ee2be2a8	241	Standard_Real LocalU, LocalV;
7fd59977	242	gp_Vec D1U, D1V;
	243	gp_Dir LocalDir;
	244	for (Standard_Integer i = 1; i <= ProjectorOnSurface.NbPoints(); i++)
	245	{
	246	ProjectorOnSurface.Parameters( i, LocalU, LocalV );
	247
	248	SecondSurf->D1( LocalU, LocalV, EndOfArrow2, D1U, D1V );
	249	if (D1U.SquareMagnitude() <= SquareTolerance \|\| D1V.SquareMagnitude() <= SquareTolerance)
	250	LocalDir = gp_Dir( gp_Vec( AttachmentPoint1, ProjectorOnSurface.Point( i ) ) );
	251	else
	252	LocalDir = gp_Dir( D1U ^ D1V );
	253	if (DirAttach.IsParallel( LocalDir, Precision::Angular() ) && ProjectorOnSurface.Distance( i ) < MinDist)
	254	{
	255	Index = i;
	256	MinDist = ProjectorOnSurface.Distance( i );
	257	}
	258	}
	259	EndOfArrow2 = ProjectorOnSurface.Point( Index );
	260	ProjectorOnSurface.Parameters( Index, U1, V1 );
	261
	262	if ((FirstArrowLength + SecondArrowLength)*(FirstArrowLength + SecondArrowLength) <
	263	AttachmentPoint1.SquareDistance( EndOfArrow2 ))
	264	DirOfArrow1 = -DirAttach;
	265	else
	266	DirOfArrow1 = DirAttach;
	267
08cd2f6b	268	if (EndOfArrow2.SquareDistance( AttachmentPoint2 ) > Precision::SquareConfusion())
7fd59977	269	{
	270	VCurve = SecondSurf->VIso( V1 );
	271	ProjectorOnCurve.Init( EndOfArrow2, VCurve );
	272	FirstU = ProjectorOnCurve.LowerDistanceParameter();
	273
	274	ProjectorOnSurface.Init( AttachmentPoint2, SecondSurf );
	275	ProjectorOnSurface.LowerDistanceParameters( U2, V2 );
	276	UCurve = SecondSurf->UIso( U2 );
	277
	278	ProjectorOnCurve.Init( AttachmentPoint2, UCurve );
	279	LastV = ProjectorOnCurve.LowerDistanceParameter();
	280
	281	gp_Pnt Intersection = SecondSurf->Value( U2, V1 );
	282	ProjectorOnCurve.Init( Intersection, VCurve );
	283	LastU = ProjectorOnCurve.LowerDistanceParameter();
	284	ProjectorOnCurve.Init( Intersection, UCurve );
	285	FirstV = ProjectorOnCurve.LowerDistanceParameter();
	286
	287	deltaU = LastU - FirstU;
	288	deltaV = LastV - FirstV;
	289
	290	if (VCurve->IsPeriodic() && Abs( deltaU ) > VCurve->Period()/2)
	291	{
	292	Standard_Real Sign = (deltaU > 0.0)? -1.0 : 1.0;
	293	deltaU = VCurve->Period() - Abs( deltaU );
	294	deltaU *= Sign;
	295	}
	296	if (UCurve->IsPeriodic() && Abs( deltaV ) > UCurve->Period()/2)
	297	{
	298	Standard_Real Sign = (deltaV > 0.0)? -1.0 : 1.0;
	299	deltaV = UCurve->Period() - Abs( deltaV );
	300	deltaV *= Sign;
	301	}
	302	}
	303	}
	304
	305
	306	//=======================================================================
	307	//function : ComputeFacesAnglePresentation
	308	//purpose :
	309	//=======================================================================
	310
	311	void DsgPrs::ComputeFacesAnglePresentation( const Standard_Real ArrowLength,
	312	const Standard_Real Value,
	313	const gp_Pnt& CenterPoint,
	314	const gp_Pnt& AttachmentPoint1,
	315	const gp_Pnt& AttachmentPoint2,
	316	const gp_Dir& dir1,
	317	const gp_Dir& dir2,
	318	const gp_Dir& axisdir,
	319	const Standard_Boolean isPlane,
	320	const gp_Ax1& AxisOfSurf,
	321	const gp_Pnt& OffsetPoint,
	322	gp_Circ & AngleCirc,
	323	Standard_Real & FirstParAngleCirc,
	324	Standard_Real & LastParAngleCirc,
	325	gp_Pnt & EndOfArrow1,
	326	gp_Pnt & EndOfArrow2,
	327	gp_Dir & DirOfArrow1,
	328	gp_Dir & DirOfArrow2,
	329	gp_Pnt & ProjAttachPoint2,
	330	gp_Circ & AttachCirc,
	331	Standard_Real & FirstParAttachCirc,
	332	Standard_Real & LastParAttachCirc )
333	{
c6541a0c	334	if (Value > Precision::Angular() && Abs( M_PI-Value ) > Precision::Angular())
7fd59977	335	{
	336	// Computing presentation of angle's arc
	337	gp_Ax2 ax( CenterPoint, axisdir, dir1 );
	338	AngleCirc.SetPosition( ax );
	339	AngleCirc.SetRadius( CenterPoint.Distance( OffsetPoint ) );
	340	gp_Vec vec1( dir1 );
	341	vec1 *= AngleCirc.Radius();
	342	gp_Pnt p1 = CenterPoint.Translated( vec1 );
	343	gp_Vec vec2( dir2 );
	344	vec2 *= AngleCirc.Radius();
	345	gp_Pnt p2 = CenterPoint.Translated( vec2 );
	346
	347	Standard_Real Par1 = 0.;
	348	Standard_Real Par2 = ElCLib::Parameter( AngleCirc, p2 );
	349	Standard_Real Par0 = ElCLib::Parameter( AngleCirc, OffsetPoint );
	350
	351	gp_Vec PosVec( CenterPoint, OffsetPoint );
	352	gp_Vec NormalOfPlane = vec1 ^ vec2;
	353
	354	gp_Vec Normal1 = NormalOfPlane ^ vec1;
	355	gp_Vec Normal2 = NormalOfPlane ^ vec2;
	356	Standard_Integer Sign1 = (PosVec * Normal1 >= 0)? 1 : -1;
	357	Standard_Integer Sign2 = (PosVec * Normal2 >= 0)? 1 : -1;
	358	if (Sign1 == 1 && Sign2 == -1)
	359	{
	360	FirstParAngleCirc = Par1;
	361	LastParAngleCirc = Par2;
	362	}
	363	else if (Sign1 == 1 && Sign2 == 1)
	364	{
	365	FirstParAngleCirc = Par1;
	366	LastParAngleCirc = Par0;
	367	}
	368	else if (Sign1 == -1 && Sign2 == 1)
	369	{
c6541a0c D	370	Par1 += M_PI;
c6541a0c D	371	Par2 += M_PI;
7fd59977	372	FirstParAngleCirc = Par1;
	373	LastParAngleCirc = Par2;
	374	}
	375	else //Sign1 == -1 && Sign2 == -1
	376	{
	377	AngleCirc.SetPosition( gp_Ax2( CenterPoint, axisdir, gp_Dir( PosVec ) ) );
	378	Par0 = 0.;
	379	Par1 = ElCLib::Parameter( AngleCirc, p1 );
	380	Par2 = ElCLib::Parameter( AngleCirc, p2 );
	381	FirstParAngleCirc = Par0;
	382	LastParAngleCirc = Par2;
	383	}
	384
	385	// Computing presentation of arrows
	386	EndOfArrow1 = ElCLib::Value( Par1, AngleCirc );
	387	EndOfArrow2 = ElCLib::Value( Par2, AngleCirc );
	388	Standard_Real beta = 0.;
	389	if (AngleCirc.Radius() > Precision::Confusion())
	390	beta = ArrowLength / AngleCirc.Radius();
	391	gp_Pnt OriginOfArrow1 = ElCLib::Value( Par1 + beta, AngleCirc );
	392	gp_Pnt OriginOfArrow2 = ElCLib::Value( Par2 - beta, AngleCirc );
	393	DirOfArrow1 = gp_Dir( gp_Vec( OriginOfArrow1, EndOfArrow1 ) );
	394	DirOfArrow2 = gp_Dir( gp_Vec( OriginOfArrow2, EndOfArrow2 ) );
	395	if (EndOfArrow1.SquareDistance( EndOfArrow2 ) <= (ArrowLength + ArrowLength)*(ArrowLength + ArrowLength))
	396	{
	397	DirOfArrow1.Reverse();
	398	DirOfArrow2.Reverse();
	399	}
	400	}
	401	else // dir1 and dir2 are parallel
	402	{
	403	gp_Dir ArrowDir = axisdir ^ dir1;
	404	DirOfArrow1 = ArrowDir;
	405	DirOfArrow2 = -ArrowDir;
	406	gp_Lin DirLine( AttachmentPoint1, dir1 );
	407	EndOfArrow1 = ElCLib::Value( ElCLib::Parameter( DirLine, OffsetPoint ), DirLine );
	408	EndOfArrow2 = EndOfArrow1;
	409	}
	410
	411	// Line or arc from AttachmentPoint2 to its "projection"
	412	gp_Lin SecondLin( CenterPoint, dir2 );
	413	if (SecondLin.Contains( AttachmentPoint2, Precision::Confusion() ))
	414	ProjAttachPoint2 = AttachmentPoint2;
	415	else
	416	{
	417	if (isPlane)
	418	ProjAttachPoint2 = ElCLib::Value( ElCLib::Parameter( SecondLin, AttachmentPoint2 ), SecondLin );
	419	else
	420	{
	421	gp_Lin LineOfAxis( AxisOfSurf );
	422	gp_Pnt CenterOfArc = ElCLib::Value( ElCLib::Parameter( LineOfAxis, AttachmentPoint2 ),
	423	LineOfAxis );
	424
	425	gp_Ax2 Ax2( CenterOfArc,
	426	AxisOfSurf.Direction(),
	427	gp_Dir( gp_Vec( CenterOfArc, AttachmentPoint2 ) ) );
	428	AttachCirc.SetPosition( Ax2 );
	429	AttachCirc.SetRadius( CenterOfArc.Distance( AttachmentPoint2 ) );
	430
	431	GeomAPI_ExtremaCurveCurve Intersection( new Geom_Circle( AttachCirc ),
	432	new Geom_Line( SecondLin ) );
	433	Intersection.NearestPoints( ProjAttachPoint2, ProjAttachPoint2 );
	434
	435	Standard_Real U2 = ElCLib::Parameter( AttachCirc, ProjAttachPoint2 );
c6541a0c	436	if (U2 <= M_PI)
7fd59977	437	{
	438	FirstParAttachCirc = 0;
	439	LastParAttachCirc = U2;
	440	}
	441	else
	442	{
	443	FirstParAttachCirc = U2;
c6541a0c	444	LastParAttachCirc = 2*M_PI;
7fd59977	445	}
	446	}
	447	}
	448	}
	449
	450
	451
35e08fe8	452	void DsgPrs::ComputeFilletRadiusPresentation( const Standard_Real /ArrowLength/,
7fd59977	453	const Standard_Real Value,
	454	const gp_Pnt & Position,
	455	const gp_Dir & NormalDir,
	456	const gp_Pnt & FirstPoint,
	457	const gp_Pnt & SecondPoint,
	458	const gp_Pnt & Center,
	459	const gp_Pnt & BasePnt,
	460	const Standard_Boolean drawRevers,
	461	Standard_Boolean & SpecCase,
	462	gp_Circ & FilletCirc,
	463	Standard_Real & FirstParCirc,
	464	Standard_Real & LastParCirc,
	465	gp_Pnt & EndOfArrow,
	466	gp_Dir & DirOfArrow,
	467	gp_Pnt & DrawPosition)
	468	{
	469	gp_Dir dir1(gp_Vec(Center, FirstPoint));
	470	gp_Dir dir2(gp_Vec(Center, SecondPoint));
	471	Standard_Real Angle = dir1.Angle(dir2);
c6541a0c	472	if(Angle <= Precision::Angular() \|\| ( M_PI - Angle ) <= Precision::Angular() \|\|
7fd59977	473	Value <= Precision::Confusion()) SpecCase = Standard_True;
	474	else SpecCase = Standard_False;
	475	if ( !SpecCase )
	476	{
	477	// Computing presentation of fillet's arc
	478	gp_Ax2 ax( Center, NormalDir, dir1 );
	479	FilletCirc.SetPosition( ax );
	480	FilletCirc.SetRadius( Center.Distance( FirstPoint ) ); //***
	481	gp_Vec vec1( dir1 );
	482	vec1 *= FilletCirc.Radius();
7fd59977	483	gp_Vec vec2( dir2 );
7fd59977	484	vec2 *= FilletCirc.Radius();
7fd59977	485	gp_Vec PosVec;
	486	if(! Center.IsEqual( Position, Precision::Confusion() ))
	487	PosVec.SetXYZ( gp_Vec(Center, Position).XYZ() );
	488	else
	489	PosVec.SetXYZ( (vec1.Added(vec2)).XYZ() );
	490	gp_Vec NormalOfPlane = vec1 ^ vec2;
	491	gp_Vec Normal1 = NormalOfPlane ^ vec1;
	492	gp_Vec Normal2 = NormalOfPlane ^ vec2;
	493	Standard_Integer Sign1 = (PosVec * Normal1 >= 0)? 1 : -1;
	494	Standard_Integer Sign2 = (PosVec * Normal2 >= 0)? 1 : -1;
	495	gp_Lin L1( Center, dir1 );
	496	gp_Lin L2( Center, dir2 );
	497	if ( Sign1 != Sign2 )
	498	{
	499	DrawPosition = Position; //***
	500	gp_Dir direction(PosVec) ;
	501	Standard_Real angle = dir1.Angle(direction) ;
	502	if (( dir1 ^ direction) * NormalDir < 0.0e0) angle = -angle ;
c6541a0c	503	if(Sign1 == -1) angle += M_PI;
7fd59977	504	EndOfArrow = ElCLib::Value(angle, FilletCirc); //***
	505
	506	}
	507	else
	508	{
	509	if(L1.Distance(Position) < L2.Distance(Position))
	510	{
	511	EndOfArrow = FirstPoint; //***
	512	DrawPosition = ElCLib::Value(ElCLib::Parameter(L1, Position), L1);
	513	}
	514	else
	515	{
	516	EndOfArrow = SecondPoint; //***
	517	DrawPosition = ElCLib::Value(ElCLib::Parameter(L2, Position), L2);
	518	}
	519	}
	520	if((dir1^dir2).IsOpposite(NormalDir, Precision::Angular()))
	521	{
	522	gp_Dir newdir = NormalDir.Reversed() ;
	523	gp_Ax2 axnew( Center, newdir, dir1 );
	524	FilletCirc.SetPosition( axnew );
	525	}
	526	FirstParCirc = ElCLib::Parameter( FilletCirc, FirstPoint );
	527	LastParCirc = ElCLib::Parameter( FilletCirc, SecondPoint );
7fd59977	528	}
	529	else //Angle equal 0 or PI or R = 0
	530	{
	531	DrawPosition = Position;
	532	EndOfArrow = BasePnt;
	533	}
	534
7fd59977	535	if(drawRevers)
	536	{
	537	gp_Vec Vd(DrawPosition, EndOfArrow);
	538	DrawPosition.Translate(Vd *2);
	539	}
	540	DirOfArrow.SetXYZ(gp_Dir(gp_Vec(DrawPosition, EndOfArrow)).XYZ());
	541	}
	542
	543	//=======================================================================
	544	//function : ComputeRadiusLine
	545	//purpose :
	546	//=======================================================================
	547
	548	void DsgPrs::ComputeRadiusLine(const gp_Pnt & aCenter,
	549	const gp_Pnt & anEndOfArrow,
	550	const gp_Pnt & aPosition,
	551	const Standard_Boolean drawFromCenter,
	552	gp_Pnt & aRadLineOrign,
	553	gp_Pnt & aRadLineEnd)
	554	{
	555	if(drawFromCenter)
	556	{
	557	gp_Lin RadiusLine = gce_MakeLin( aCenter, anEndOfArrow );
	558	Standard_Real PosParOnLine = ElCLib::Parameter( RadiusLine, aPosition );
	559	Standard_Real EndOfArrowPar = ElCLib::Parameter( RadiusLine, anEndOfArrow );
	560	if (PosParOnLine < 0.0)
	561	{
	562	aRadLineOrign = aPosition;
	563	aRadLineEnd = anEndOfArrow;
	564	}
	565	else if (PosParOnLine > EndOfArrowPar)
	566	{
	567	aRadLineOrign = aPosition;
	568	aRadLineEnd = aCenter;
	569	}
	570	else
	571	{
	572	aRadLineOrign = aCenter;
	573	aRadLineEnd = anEndOfArrow;
	574	}
	575	}
	576	else
	577	{
	578	aRadLineOrign = aPosition;
	579	aRadLineEnd = anEndOfArrow;
	580	}
	581	}
	582
	583
	584	//=======================================================================
	585	//function : DistanceFromApex
	586	//purpose :
	587	//=======================================================================
	588
	589	Standard_Real DsgPrs::DistanceFromApex(const gp_Elips & elips,
	590	const gp_Pnt & Apex,
	591	const Standard_Real par)
	592	{
	593	Standard_Real dist;
	594	Standard_Real parApex = ElCLib::Parameter ( elips, Apex );
c6541a0c	595	if(parApex == 0.0 \|\| parApex == M_PI)
7fd59977	596	{//Major case
7fd59977	597	if(parApex == 0.0) //pos Apex
c6541a0c	598	dist = (par < M_PI) ? par : (2*M_PI - par);
7fd59977	599	else //neg Apex
c6541a0c	600	dist = (par < M_PI) ? ( M_PI - par) : ( par - M_PI );
7fd59977	601	}
	602	else
	603	{// Minor case
c6541a0c	604	if(parApex == M_PI / 2) //pos Apex
7fd59977	605	{
c6541a0c	606	if(par <= parApex + M_PI && par > parApex )
7fd59977	607	dist = par - parApex;
	608	else
	609	{
c6541a0c D	610	if(par > parApex + M_PI)
c6541a0c D	611	dist = 2*M_PI - par + parApex;
7fd59977	612	else
c6541a0c	613	dist = parApex - par; // 0 < par < M_PI/2
7fd59977	614	}
	615	}
	616	else //neg Apex == 3/2 PI
	617	{
c6541a0c	618	if(par <= parApex && par >= M_PI/2)
7fd59977	619	dist = parApex - par;
	620	else
	621	{
	622	if(par > parApex)
	623	dist = par - parApex;
	624	else
c6541a0c	625	dist = par + M_PI/2; // 0 < par < PI/2
7fd59977	626	}
	627	}
	628	}
	629	return dist;
	630	}