[occt.git] / src / StdPrs / StdPrs_WFDeflectionRestrictedFace.cxx

// Created on: 1995-08-07
// Created by: Modelistation
// 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.

#include <StdPrs_WFDeflectionRestrictedFace.ixx>

#include <Hatch_Hatcher.hxx>
#include <Graphic3d_Group.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Prs3d_IsoAspect.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <GCPnts_QuasiUniformDeflection.hxx>
#include <Adaptor3d_IsoCurve.hxx>
#include <StdPrs_DeflectionCurve.hxx>
#include <StdPrs_ToolRFace.hxx>
#include <Bnd_Box2d.hxx>
#include <BndLib_Add2dCurve.hxx>
#include <Precision.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Geom_Curve.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Geom_Surface.hxx>
#include <TColgp_SequenceOfPnt2d.hxx>


#ifdef DEB_MESH
#include <OSD_Chronometer.hxx>
extern OSD_Chronometer FFaceTimer1,FFaceTimer2,FFaceTimer3,FFaceTimer4;
#endif


//==================================================================
// function: FindLimits
// purpose:
//==================================================================
static void FindLimits(const Adaptor3d_Curve& aCurve,
		       const Standard_Real  aLimit,
		       Standard_Real&       First,
		       Standard_Real&       Last)
{
  First = Max(aCurve.FirstParameter(), First);
  Last  = Min(aCurve.LastParameter(), Last);
  Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
  Standard_Boolean lastInf  = Precision::IsPositiveInfinite(Last);

  if (firstInf || lastInf) {
    gp_Pnt P1,P2;
    Standard_Real delta = 1;
    if (firstInf && lastInf) {
      do {
	delta *= 2;
	First = - delta;
	Last  =   delta;
	aCurve.D0(First,P1);
	aCurve.D0(Last,P2);
      } while (P1.Distance(P2) < aLimit);
    }
    else if (firstInf) {
      aCurve.D0(Last,P2);
      do {
	delta *= 2;
	First = Last - delta;
	aCurve.D0(First,P1);
      } while (P1.Distance(P2) < aLimit);
    }
    else if (lastInf) {
      aCurve.D0(First,P1);
      do {
	delta *= 2;
	Last = First + delta;
	aCurve.D0(Last,P2);
      } while (P1.Distance(P2) < aLimit);
    }
  }    

}


//=========================================================================
// function: Add
// purpose
//=========================================================================
void StdPrs_WFDeflectionRestrictedFace::Add
  (const Handle (Prs3d_Presentation)& aPresentation,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Standard_Boolean DrawUIso,
   const Standard_Boolean DrawVIso,
   const Quantity_Length Deflection,
   const Standard_Integer NBUiso,
   const Standard_Integer NBViso,
   const Handle(Prs3d_Drawer)& aDrawer,
   Prs3d_NListOfSequenceOfPnt& Curves) {

#ifdef DEB_MESH
  FFaceTimer1.Start();
#endif

  StdPrs_ToolRFace ToolRst (aFace);
  Standard_Real UF, UL, VF, VL;
  UF = aFace->FirstUParameter();
  UL = aFace->LastUParameter();
  VF = aFace->FirstVParameter();
  VL = aFace->LastVParameter();

  Standard_Real aLimit = aDrawer->MaximalParameterValue();

  // compute bounds of the restriction
  Standard_Real UMin,UMax,VMin,VMax;
  //Standard_Real u,v,step;
  Standard_Integer i;//,nbPoints = 10;

  UMin = Max(UF, -aLimit);
  UMax = Min(UL, aLimit);
  VMin = Max(VF, -aLimit);
  VMax = Min(VL, aLimit);


  // update min max for the hatcher.
  gp_Pnt2d P1,P2;
  Standard_Real U1, U2;
  gp_Pnt dummypnt;
  Standard_Real ddefle= Max(UMax-UMin, VMax-VMin) * aDrawer->DeviationCoefficient();
  TColgp_SequenceOfPnt2d tabP;
  Standard_Real aHatchingTol = 1.e100;

  UMin = VMin = 1.e100;
  UMax = VMax = -1.e100;
  
  for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
    TopAbs_Orientation Orient = ToolRst.Orientation();
    if ( Orient == TopAbs_FORWARD || Orient == TopAbs_REVERSED ) {
      Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
      if (TheRCurve->GetType() != GeomAbs_Line) {
        GCPnts_QuasiUniformDeflection UDP(*TheRCurve, ddefle);
	if (UDP.IsDone()) {
	  Standard_Integer NumberOfPoints = UDP.NbPoints();
	  if ( NumberOfPoints >= 2 ) {
	    dummypnt = UDP.Value(1);
	    P2.SetCoord(dummypnt.X(), dummypnt.Y());
	    UMin = Min(P2.X(), UMin);
	    UMax = Max(P2.X(), UMax);
	    VMin = Min(P2.Y(), VMin);
	    VMax = Max(P2.Y(), VMax);
	    for (i = 2; i <= NumberOfPoints; i++) {
	      P1 = P2;
	      dummypnt = UDP.Value(i);
	      P2.SetCoord(dummypnt.X(), dummypnt.Y());
	      UMin = Min(P2.X(), UMin);
	      UMax = Max(P2.X(), UMax);
	      VMin = Min(P2.Y(), VMin);
	      VMax = Max(P2.Y(), VMax);
              aHatchingTol = Min(P1.SquareDistance(P2), aHatchingTol);

	      if(Orient == TopAbs_FORWARD ) {
		//isobuild.Trim(P1,P2);
		tabP.Append(P1);
		tabP.Append(P2);
	      }
	      else {
		//isobuild.Trim(P2,P1);
		tabP.Append(P2);
		tabP.Append(P1);
	      }
	    }
	  }
	}
	else {
	  cout << "Cannot evaluate curve on surface"<<endl;
	}
      }
      else {
	U1 = TheRCurve->FirstParameter();
	U2 = TheRCurve->LastParameter();
        // MSV 17.08.06 OCC13144: U2 occured less than U1, to overcome it
        // ensure that distance U2-U1 is not greater than aLimit*2,
        // if greater then choose an origin and use aLimit to define
        // U1 and U2 anew
        Standard_Real aOrigin = 0.;
        if (!Precision::IsNegativeInfinite(U1) || !Precision::IsPositiveInfinite(U2)) {
          if (Precision::IsNegativeInfinite(U1))
            aOrigin = U2 - aLimit;
          else if (Precision::IsPositiveInfinite(U2))
            aOrigin = U1 + aLimit;
          else
            aOrigin = (U1 + U2) * 0.5;
        }
	U1 = Max(aOrigin - aLimit, U1);
	U2 = Min(aOrigin + aLimit, U2);
	P1 = TheRCurve->Value(U1);
	P2 = TheRCurve->Value(U2);
	UMin = Min(P1.X(), UMin);
	UMax = Max(P1.X(), UMax);
	VMin = Min(P1.Y(), VMin);
	VMax = Max(P1.Y(), VMax);
	UMin = Min(P2.X(), UMin);
	UMax = Max(P2.X(), UMax);
	VMin = Min(P2.Y(), VMin);
	VMax = Max(P2.Y(), VMax);
        aHatchingTol = Min(P1.SquareDistance(P2), aHatchingTol);

	if(Orient == TopAbs_FORWARD ) {
	 // isobuild.Trim(P1,P2);
	  tabP.Append(P1);
	  tabP.Append(P2);
	}
	else {
	  //isobuild.Trim(P2,P1);
	  tabP.Append(P2);
	  tabP.Append(P1);
	}
      }
    }
  }


#ifdef DEB_MESH
  FFaceTimer1.Stop();

  FFaceTimer2.Start();
#endif

  // Compute the hatching tolerance.
  aHatchingTol *= 0.1;
  aHatchingTol = Max(Precision::Confusion(), aHatchingTol);
  aHatchingTol = Min(1.e-5, aHatchingTol);

  // load the isos
  Hatch_Hatcher isobuild(aHatchingTol, ToolRst.IsOriented());
  Standard_Boolean UClosed = aFace->IsUClosed();
  Standard_Boolean VClosed = aFace->IsVClosed();

  if ( ! UClosed ) {
    UMin = UMin + ( UMax - UMin) /1000.;
    UMax = UMax - ( UMax - UMin) /1000.; 
  }

  if ( ! VClosed ) {
    VMin = VMin + ( VMax - VMin) /1000.;
    VMax = VMax - ( VMax - VMin) /1000.; 
  }

  if (DrawUIso){
    if (NBUiso > 0) {
      UClosed = Standard_False; // En attendant un hatcher de course.
      Standard_Real du= UClosed ? (UMax-UMin)/NBUiso : (UMax-UMin)/(1+NBUiso);
      for (i=1; i<=NBUiso;i++){
	isobuild.AddXLine(UMin+du*i);
      }
    }
  }
  if (DrawVIso){
    if ( NBViso > 0) {
      VClosed = Standard_False;
      Standard_Real dv= VClosed ?(VMax-VMin)/NBViso : (VMax-VMin)/(1+NBViso);
      for (i=1; i<=NBViso;i++){
	isobuild.AddYLine(VMin+dv*i);
      }
    }
  }

#ifdef DEB_MESH
  FFaceTimer2.Stop();
  FFaceTimer3.Start();
#endif

  
  Standard_Integer ll = tabP.Length();
  for (i = 1; i <= ll; i+=2) {
    isobuild.Trim(tabP(i),tabP(i+1));
  }


#ifdef DEB_MESH  
  FFaceTimer3.Stop();
  FFaceTimer4.Start();
#endif

  // draw the isos

  Adaptor3d_IsoCurve anIso;
  anIso.Load(aFace);
  Handle(Geom_Curve) BC;
  const BRepAdaptor_Surface& BS = *(BRepAdaptor_Surface*)&(aFace->Surface());
  GeomAbs_SurfaceType thetype = aFace->GetType();

  Standard_Integer NumberOfLines = isobuild.NbLines();
  Handle(Geom_Surface) GB;
  if (thetype == GeomAbs_BezierSurface) {
    GB = BS.Bezier();
  }
  else if (thetype == GeomAbs_BSplineSurface){
    GB = BS.BSpline();
  }

  Standard_Real anAngle = aDrawer->DeviationAngle();

  for (i = 1; i <= NumberOfLines; i++) {
    Standard_Integer NumberOfIntervals = isobuild.NbIntervals(i);
    Standard_Real Coord = isobuild.Coordinate(i);
    for (Standard_Integer j = 1; j <= NumberOfIntervals; j++) {
      Standard_Real b1=isobuild.Start(i,j),b2=isobuild.End(i,j);


      if (!GB.IsNull()) {
	if (isobuild.IsXLine(i))
	  BC = GB->UIso(Coord);
	else 
	  BC = GB->VIso(Coord);
	GeomAdaptor_Curve GC(BC);
	FindLimits(GC, aLimit,b1, b2);
	if (b2-b1>Precision::Confusion()) {
	  Handle(TColgp_HSequenceOfPnt) Points = new TColgp_HSequenceOfPnt;
	  StdPrs_DeflectionCurve::Add (aPresentation, GC, b1, b2, Deflection, 
                                       Points->ChangeSequence(), anAngle, Standard_False);
	  Curves.Append(Points);
	}
      }
      else {
	if (isobuild.IsXLine(i))
	  anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
	else
	  anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
	FindLimits(anIso, aLimit,b1, b2);
	if (b2-b1>Precision::Confusion()) {
	  Handle(TColgp_HSequenceOfPnt) Points = new TColgp_HSequenceOfPnt;
	  StdPrs_DeflectionCurve::Add (aPresentation, anIso, b1, b2, Deflection, 
                                       Points->ChangeSequence(), anAngle, Standard_False);
	  Curves.Append(Points);
	}
      }
    }
  }
#ifdef DEB_MESH
  FFaceTimer4.Stop();
#endif
}


//=========================================================================
// function: Match
// purpose
//=========================================================================
Standard_Boolean StdPrs_WFDeflectionRestrictedFace::Match
  (const Quantity_Length X,
   const Quantity_Length Y,
   const Quantity_Length Z,
   const Quantity_Length aDistance,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle(Prs3d_Drawer)& aDrawer,
   const Standard_Boolean DrawUIso,
   const Standard_Boolean DrawVIso,
   const Quantity_Length Deflection,
   const Standard_Integer NBUiso,
   const Standard_Integer NBViso)
{

   StdPrs_ToolRFace ToolRst (aFace);
   const Standard_Real aLimit = aDrawer->MaximalParameterValue();

  // compute bounds of the restriction
  Standard_Real UMin,UMax,VMin,VMax;
  Standard_Real u,v,step;
  Standard_Integer i,nbPoints = 10;
  UMin = VMin = RealLast();
  UMax = VMax = RealFirst();
  
  for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
    Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
    u = TheRCurve->FirstParameter();
    v = TheRCurve->LastParameter();
    step = ( v - u) / nbPoints;
    for (i = 0; i <= nbPoints; i++) {
      gp_Pnt2d P = TheRCurve->Value(u);
      if (P.X() < UMin) UMin = P.X();
      if (P.X() > UMax) UMax = P.X();
      if (P.Y() < VMin) VMin = P.Y();
      if (P.Y() > VMax) VMax = P.Y();
      u += step;
    }
  }
  
  // load the isos
  Hatch_Hatcher isobuild(1.e-5,ToolRst.IsOriented());
  Standard_Boolean UClosed = aFace->IsUClosed();
  Standard_Boolean VClosed = aFace->IsVClosed();

  if ( ! UClosed ) {
    UMin = UMin + ( UMax - UMin) /1000.;
    UMax = UMax - ( UMax - UMin) /1000.; 
  }

  if ( ! VClosed ) {
    VMin = VMin + ( VMax - VMin) /1000.;
    VMax = VMax - ( VMax - VMin) /1000.; 
  }

  if (DrawUIso){
    if (NBUiso > 0) {
      UClosed = Standard_False; // En attendant un hatcher de course.
      Standard_Real du= UClosed ? (UMax-UMin)/NBUiso : (UMax-UMin)/(1+NBUiso);
      for (i=1; i<=NBUiso;i++){
	isobuild.AddXLine(UMin+du*i);
      }
    }
  }
  if (DrawVIso){
    if ( NBViso > 0) {
      VClosed = Standard_False;
      Standard_Real dv= VClosed ?(VMax-VMin)/NBViso : (VMax-VMin)/(1+NBViso);
      for (i=1; i<=NBViso;i++){
	isobuild.AddYLine(VMin+dv*i);
      }
    }
  }

  // trim the isos
  gp_Pnt2d P1,P2;
  gp_Pnt dummypnt;
  for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
    TopAbs_Orientation Orient = ToolRst.Orientation();
    if ( Orient == TopAbs_FORWARD || Orient == TopAbs_REVERSED ) {
      Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
      GCPnts_QuasiUniformDeflection UDP(*TheRCurve, Deflection);
      if (UDP.IsDone()) {
	Standard_Integer NumberOfPoints = UDP.NbPoints();
	if ( NumberOfPoints >= 2 ) {
	  dummypnt = UDP.Value(1);
	  P2.SetCoord(dummypnt.X(), dummypnt.Y());
	  for (i = 2; i <= NumberOfPoints; i++) {
	    P1 = P2;
	    dummypnt = UDP.Value(i);
	    P2.SetCoord(dummypnt.X(), dummypnt.Y());
	    if(Orient == TopAbs_FORWARD )
              isobuild.Trim(P1,P2);
            else
              isobuild.Trim(P2,P1);
	  }
	}
      }
      else {
	cout << "Cannot evaluate curve on surface"<<endl;
      }
    }
  }
  
  // draw the isos

  Adaptor3d_IsoCurve anIso;
  anIso.Load(aFace);
  Standard_Integer NumberOfLines = isobuild.NbLines();
  Standard_Real anAngle = aDrawer->DeviationAngle();

  for (i = 1; i <= NumberOfLines; i++) {
    Standard_Integer NumberOfIntervals = isobuild.NbIntervals(i);
    Standard_Real Coord = isobuild.Coordinate(i);
    for (Standard_Integer j = 1; j <= NumberOfIntervals; j++) {
      Standard_Real b1=isobuild.Start(i,j),b2=isobuild.End(i,j);

      b1 = b1 == RealFirst() ? - aLimit : b1;
      b2 = b2 == RealLast()  ?   aLimit : b2;

      if (isobuild.IsXLine(i))
	anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
      else
	anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
    
      if (StdPrs_DeflectionCurve::Match(X,Y,Z,aDistance,anIso, b1, b2, Deflection, anAngle))
	  return Standard_True;
    }
  }
  return Standard_False;
}


//=========================================================================
// function: Add
// purpose
//=========================================================================
void StdPrs_WFDeflectionRestrictedFace::Add
  (const Handle (Prs3d_Presentation)& aPresentation,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle (Prs3d_Drawer)& aDrawer)
{
  Prs3d_NListOfSequenceOfPnt Curves;
  StdPrs_WFDeflectionRestrictedFace::Add (aPresentation,
					  aFace,
					  Standard_True,
					  Standard_True,
					  aDrawer->MaximalChordialDeviation(),
					  aDrawer->UIsoAspect()->Number(),
					  aDrawer->VIsoAspect()->Number(),
					  aDrawer,
					  Curves);
}


//=========================================================================
// function: AddUIso
// purpose
//=========================================================================
void StdPrs_WFDeflectionRestrictedFace::AddUIso
  (const Handle (Prs3d_Presentation)& aPresentation,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle (Prs3d_Drawer)& aDrawer)
{
  Prs3d_NListOfSequenceOfPnt Curves;
  StdPrs_WFDeflectionRestrictedFace::Add ( 
		      aPresentation,
		      aFace,
		      Standard_True,
		      Standard_False,
		      aDrawer->MaximalChordialDeviation(),
		      aDrawer->UIsoAspect()->Number(),
		      aDrawer->VIsoAspect()->Number(),
		      aDrawer,
		      Curves);
}


//=========================================================================
// function: AddVIso
// purpose
//=========================================================================
void StdPrs_WFDeflectionRestrictedFace::AddVIso
  (const Handle (Prs3d_Presentation)& aPresentation,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle (Prs3d_Drawer)& aDrawer)
{
  Prs3d_NListOfSequenceOfPnt Curves;
  StdPrs_WFDeflectionRestrictedFace::Add ( 
		      aPresentation,
		      aFace,
		      Standard_False,
		      Standard_True,
		      aDrawer->MaximalChordialDeviation(),
		      aDrawer->UIsoAspect()->Number(),
		      aDrawer->VIsoAspect()->Number(),
		      aDrawer,
		      Curves);
}


//=========================================================================
// function: Match
// purpose
//=========================================================================
Standard_Boolean StdPrs_WFDeflectionRestrictedFace::Match
  (const Quantity_Length X,
   const Quantity_Length Y,
   const Quantity_Length Z,
   const Quantity_Length aDistance,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle (Prs3d_Drawer)& aDrawer)
{
  return StdPrs_WFDeflectionRestrictedFace::Match (  
                      X,Y,Z,aDistance,
                      aFace,
                      aDrawer,
                      Standard_True,
                      Standard_True,
                      aDrawer->MaximalChordialDeviation(),
                      aDrawer->UIsoAspect()->Number(),
                      aDrawer->VIsoAspect()->Number());
}


//=========================================================================
// function: MatchUIso
// purpose
//=========================================================================
Standard_Boolean StdPrs_WFDeflectionRestrictedFace::MatchUIso
  (const Quantity_Length X,
   const Quantity_Length Y,
   const Quantity_Length Z,
   const Quantity_Length aDistance,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle (Prs3d_Drawer)& aDrawer)
{
  return StdPrs_WFDeflectionRestrictedFace::Match ( 
                      X,Y,Z,aDistance,
                      aFace,
                      aDrawer,
                      Standard_True,
                      Standard_False,
                      aDrawer->MaximalChordialDeviation(),
                      aDrawer->UIsoAspect()->Number(),
                      aDrawer->VIsoAspect()->Number());
}


//=========================================================================
// function: MatchVIso
// purpose
//=========================================================================
Standard_Boolean StdPrs_WFDeflectionRestrictedFace::MatchVIso
  (const Quantity_Length X,
   const Quantity_Length Y,
   const Quantity_Length Z,
   const Quantity_Length aDistance,
   const Handle(BRepAdaptor_HSurface)& aFace,
   const Handle (Prs3d_Drawer)& aDrawer)
{
  return StdPrs_WFDeflectionRestrictedFace::Match ( 
                      X,Y,Z,aDistance,
                      aFace,
                      aDrawer,
                      Standard_False,
                      Standard_True,
                      aDrawer->MaximalChordialDeviation(),
                      aDrawer->UIsoAspect()->Number(),
                      aDrawer->VIsoAspect()->Number());
}
Commit	Line	Data
b311480e	1	// Created on: 1995-08-07
	2	// Created by: Modelistation
	3	// Copyright (c) 1995-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
	17	#include <StdPrs_WFDeflectionRestrictedFace.ixx>
	18
	19	#include <Hatch_Hatcher.hxx>
7fd59977	20	#include <Graphic3d_Group.hxx>
	21	#include <gp_Pnt.hxx>
	22	#include <gp_Pnt2d.hxx>
	23	#include <Prs3d_IsoAspect.hxx>
	24	#include <Adaptor2d_Curve2d.hxx>
	25	#include <GCPnts_QuasiUniformDeflection.hxx>
	26	#include <Adaptor3d_IsoCurve.hxx>
	27	#include <StdPrs_DeflectionCurve.hxx>
	28	#include <StdPrs_ToolRFace.hxx>
	29	#include <Bnd_Box2d.hxx>
	30	#include <BndLib_Add2dCurve.hxx>
	31	#include <Precision.hxx>
	32	#include <GeomAdaptor_Curve.hxx>
	33	#include <Geom_Curve.hxx>
	34	#include <GeomAbs_SurfaceType.hxx>
	35	#include <Geom_Surface.hxx>
	36	#include <TColgp_SequenceOfPnt2d.hxx>
	37
	38
	39
	40
	41	#ifdef DEB_MESH
	42	#include <OSD_Chronometer.hxx>
	43	extern OSD_Chronometer FFaceTimer1,FFaceTimer2,FFaceTimer3,FFaceTimer4;
	44	#endif
	45
	46
	47	//==================================================================
	48	// function: FindLimits
	49	// purpose:
	50	//==================================================================
	51	static void FindLimits(const Adaptor3d_Curve& aCurve,
	52	const Standard_Real aLimit,
	53	Standard_Real& First,
	54	Standard_Real& Last)
	55	{
	56	First = Max(aCurve.FirstParameter(), First);
	57	Last = Min(aCurve.LastParameter(), Last);
	58	Standard_Boolean firstInf = Precision::IsNegativeInfinite(First);
	59	Standard_Boolean lastInf = Precision::IsPositiveInfinite(Last);
	60
	61	if (firstInf \|\| lastInf) {
	62	gp_Pnt P1,P2;
	63	Standard_Real delta = 1;
	64	if (firstInf && lastInf) {
	65	do {
	66	delta *= 2;
	67	First = - delta;
	68	Last = delta;
	69	aCurve.D0(First,P1);
	70	aCurve.D0(Last,P2);
	71	} while (P1.Distance(P2) < aLimit);
	72	}
	73	else if (firstInf) {
	74	aCurve.D0(Last,P2);
	75	do {
	76	delta *= 2;
	77	First = Last - delta;
	78	aCurve.D0(First,P1);
	79	} while (P1.Distance(P2) < aLimit);
	80	}
	81	else if (lastInf) {
	82	aCurve.D0(First,P1);
	83	do {
84	delta *= 2;
85	Last = First + delta;
86	aCurve.D0(Last,P2);
87	} while (P1.Distance(P2) < aLimit);
88	}
89	}
90
91	}
92
93
94	//=========================================================================
95	// function: Add
96	// purpose
97	//=========================================================================
98	void StdPrs_WFDeflectionRestrictedFace::Add
99	(const Handle (Prs3d_Presentation)& aPresentation,
100	const Handle(BRepAdaptor_HSurface)& aFace,
101	const Standard_Boolean DrawUIso,
102	const Standard_Boolean DrawVIso,
103	const Quantity_Length Deflection,
104	const Standard_Integer NBUiso,
105	const Standard_Integer NBViso,
106	const Handle(Prs3d_Drawer)& aDrawer,
107	Prs3d_NListOfSequenceOfPnt& Curves) {
108
109	#ifdef DEB_MESH
110	FFaceTimer1.Start();
111	#endif
112
7fd59977	113	StdPrs_ToolRFace ToolRst (aFace);
	114	Standard_Real UF, UL, VF, VL;
	115	UF = aFace->FirstUParameter();
	116	UL = aFace->LastUParameter();
	117	VF = aFace->FirstVParameter();
	118	VL = aFace->LastVParameter();
	119
	120	Standard_Real aLimit = aDrawer->MaximalParameterValue();
	121
	122	// compute bounds of the restriction
	123	Standard_Real UMin,UMax,VMin,VMax;
	124	//Standard_Real u,v,step;
	125	Standard_Integer i;//,nbPoints = 10;
	126
	127	UMin = Max(UF, -aLimit);
	128	UMax = Min(UL, aLimit);
	129	VMin = Max(VF, -aLimit);
	130	VMax = Min(VL, aLimit);
	131
	132
	133	// update min max for the hatcher.
	134	gp_Pnt2d P1,P2;
	135	Standard_Real U1, U2;
	136	gp_Pnt dummypnt;
	137	Standard_Real ddefle= Max(UMax-UMin, VMax-VMin) * aDrawer->DeviationCoefficient();
	138	TColgp_SequenceOfPnt2d tabP;
1c88cbaf	139	Standard_Real aHatchingTol = 1.e100;
7fd59977	140
	141	UMin = VMin = 1.e100;
	142	UMax = VMax = -1.e100;
	143
	144	for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
	145	TopAbs_Orientation Orient = ToolRst.Orientation();
	146	if ( Orient == TopAbs_FORWARD \|\| Orient == TopAbs_REVERSED ) {
	147	Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
	148	if (TheRCurve->GetType() != GeomAbs_Line) {
	149	GCPnts_QuasiUniformDeflection UDP(*TheRCurve, ddefle);
	150	if (UDP.IsDone()) {
	151	Standard_Integer NumberOfPoints = UDP.NbPoints();
	152	if ( NumberOfPoints >= 2 ) {
	153	dummypnt = UDP.Value(1);
	154	P2.SetCoord(dummypnt.X(), dummypnt.Y());
	155	UMin = Min(P2.X(), UMin);
	156	UMax = Max(P2.X(), UMax);
	157	VMin = Min(P2.Y(), VMin);
	158	VMax = Max(P2.Y(), VMax);
	159	for (i = 2; i <= NumberOfPoints; i++) {
	160	P1 = P2;
	161	dummypnt = UDP.Value(i);
	162	P2.SetCoord(dummypnt.X(), dummypnt.Y());
	163	UMin = Min(P2.X(), UMin);
	164	UMax = Max(P2.X(), UMax);
	165	VMin = Min(P2.Y(), VMin);
	166	VMax = Max(P2.Y(), VMax);
1c88cbaf	167	aHatchingTol = Min(P1.SquareDistance(P2), aHatchingTol);
7fd59977	168
	169	if(Orient == TopAbs_FORWARD ) {
	170	//isobuild.Trim(P1,P2);
	171	tabP.Append(P1);
	172	tabP.Append(P2);
	173	}
	174	else {
	175	//isobuild.Trim(P2,P1);
	176	tabP.Append(P2);
	177	tabP.Append(P1);
	178	}
	179	}
	180	}
	181	}
	182	else {
	183	cout << "Cannot evaluate curve on surface"<<endl;
	184	}
	185	}
	186	else {
	187	U1 = TheRCurve->FirstParameter();
	188	U2 = TheRCurve->LastParameter();
	189	// MSV 17.08.06 OCC13144: U2 occured less than U1, to overcome it
	190	// ensure that distance U2-U1 is not greater than aLimit*2,
	191	// if greater then choose an origin and use aLimit to define
	192	// U1 and U2 anew
	193	Standard_Real aOrigin = 0.;
	194	if (!Precision::IsNegativeInfinite(U1) \|\| !Precision::IsPositiveInfinite(U2)) {
	195	if (Precision::IsNegativeInfinite(U1))
	196	aOrigin = U2 - aLimit;
	197	else if (Precision::IsPositiveInfinite(U2))
	198	aOrigin = U1 + aLimit;
	199	else
	200	aOrigin = (U1 + U2) * 0.5;
	201	}
	202	U1 = Max(aOrigin - aLimit, U1);
	203	U2 = Min(aOrigin + aLimit, U2);
	204	P1 = TheRCurve->Value(U1);
	205	P2 = TheRCurve->Value(U2);
	206	UMin = Min(P1.X(), UMin);
	207	UMax = Max(P1.X(), UMax);
	208	VMin = Min(P1.Y(), VMin);
	209	VMax = Max(P1.Y(), VMax);
	210	UMin = Min(P2.X(), UMin);
	211	UMax = Max(P2.X(), UMax);
	212	VMin = Min(P2.Y(), VMin);
	213	VMax = Max(P2.Y(), VMax);
1c88cbaf	214	aHatchingTol = Min(P1.SquareDistance(P2), aHatchingTol);
1c88cbaf	215
7fd59977	216	if(Orient == TopAbs_FORWARD ) {
	217	// isobuild.Trim(P1,P2);
	218	tabP.Append(P1);
	219	tabP.Append(P2);
	220	}
	221	else {
	222	//isobuild.Trim(P2,P1);
	223	tabP.Append(P2);
	224	tabP.Append(P1);
	225	}
	226	}
	227	}
	228	}
	229
	230
	231	#ifdef DEB_MESH
	232	FFaceTimer1.Stop();
	233
	234	FFaceTimer2.Start();
	235	#endif
	236
1c88cbaf	237	// Compute the hatching tolerance.
	238	aHatchingTol *= 0.1;
	239	aHatchingTol = Max(Precision::Confusion(), aHatchingTol);
	240	aHatchingTol = Min(1.e-5, aHatchingTol);
	241
7fd59977	242	// load the isos
1c88cbaf	243	Hatch_Hatcher isobuild(aHatchingTol, ToolRst.IsOriented());
7fd59977	244	Standard_Boolean UClosed = aFace->IsUClosed();
	245	Standard_Boolean VClosed = aFace->IsVClosed();
	246
	247	if ( ! UClosed ) {
	248	UMin = UMin + ( UMax - UMin) /1000.;
	249	UMax = UMax - ( UMax - UMin) /1000.;
	250	}
	251
	252	if ( ! VClosed ) {
	253	VMin = VMin + ( VMax - VMin) /1000.;
	254	VMax = VMax - ( VMax - VMin) /1000.;
	255	}
	256
	257	if (DrawUIso){
	258	if (NBUiso > 0) {
	259	UClosed = Standard_False; // En attendant un hatcher de course.
	260	Standard_Real du= UClosed ? (UMax-UMin)/NBUiso : (UMax-UMin)/(1+NBUiso);
	261	for (i=1; i<=NBUiso;i++){
	262	isobuild.AddXLine(UMin+du*i);
	263	}
	264	}
	265	}
	266	if (DrawVIso){
	267	if ( NBViso > 0) {
	268	VClosed = Standard_False;
	269	Standard_Real dv= VClosed ?(VMax-VMin)/NBViso : (VMax-VMin)/(1+NBViso);
	270	for (i=1; i<=NBViso;i++){
	271	isobuild.AddYLine(VMin+dv*i);
	272	}
	273	}
	274	}
	275
	276	#ifdef DEB_MESH
	277	FFaceTimer2.Stop();
	278	FFaceTimer3.Start();
	279	#endif
	280
	281
	282	Standard_Integer ll = tabP.Length();
	283	for (i = 1; i <= ll; i+=2) {
	284	isobuild.Trim(tabP(i),tabP(i+1));
	285	}
	286
	287
	288	#ifdef DEB_MESH
	289	FFaceTimer3.Stop();
	290	FFaceTimer4.Start();
	291	#endif
	292
	293	// draw the isos
	294
	295	Adaptor3d_IsoCurve anIso;
	296	anIso.Load(aFace);
	297	Handle(Geom_Curve) BC;
	298	const BRepAdaptor_Surface& BS = (BRepAdaptor_Surface)&(aFace->Surface());
	299	GeomAbs_SurfaceType thetype = aFace->GetType();
	300
	301	Standard_Integer NumberOfLines = isobuild.NbLines();
	302	Handle(Geom_Surface) GB;
	303	if (thetype == GeomAbs_BezierSurface) {
	304	GB = BS.Bezier();
	305	}
	306	else if (thetype == GeomAbs_BSplineSurface){
	307	GB = BS.BSpline();
308	}
309
310	Standard_Real anAngle = aDrawer->DeviationAngle();
311
312	for (i = 1; i <= NumberOfLines; i++) {
313	Standard_Integer NumberOfIntervals = isobuild.NbIntervals(i);
314	Standard_Real Coord = isobuild.Coordinate(i);
315	for (Standard_Integer j = 1; j <= NumberOfIntervals; j++) {
316	Standard_Real b1=isobuild.Start(i,j),b2=isobuild.End(i,j);
317
318
319	if (!GB.IsNull()) {
320	if (isobuild.IsXLine(i))
321	BC = GB->UIso(Coord);
322	else
323	BC = GB->VIso(Coord);
324	GeomAdaptor_Curve GC(BC);
325	FindLimits(GC, aLimit,b1, b2);
326	if (b2-b1>Precision::Confusion()) {
e3a6386d	327	Handle(TColgp_HSequenceOfPnt) Points = new TColgp_HSequenceOfPnt;
	328	StdPrs_DeflectionCurve::Add (aPresentation, GC, b1, b2, Deflection,
	329	Points->ChangeSequence(), anAngle, Standard_False);
7fd59977	330	Curves.Append(Points);
	331	}
	332	}
	333	else {
	334	if (isobuild.IsXLine(i))
	335	anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
	336	else
	337	anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
	338	FindLimits(anIso, aLimit,b1, b2);
	339	if (b2-b1>Precision::Confusion()) {
e3a6386d	340	Handle(TColgp_HSequenceOfPnt) Points = new TColgp_HSequenceOfPnt;
	341	StdPrs_DeflectionCurve::Add (aPresentation, anIso, b1, b2, Deflection,
	342	Points->ChangeSequence(), anAngle, Standard_False);
7fd59977	343	Curves.Append(Points);
	344	}
	345	}
	346	}
	347	}
	348	#ifdef DEB_MESH
	349	FFaceTimer4.Stop();
	350	#endif
	351	}
	352
	353
	354	//=========================================================================
	355	// function: Match
	356	// purpose
	357	//=========================================================================
	358	Standard_Boolean StdPrs_WFDeflectionRestrictedFace::Match
	359	(const Quantity_Length X,
	360	const Quantity_Length Y,
	361	const Quantity_Length Z,
	362	const Quantity_Length aDistance,
	363	const Handle(BRepAdaptor_HSurface)& aFace,
	364	const Handle(Prs3d_Drawer)& aDrawer,
	365	const Standard_Boolean DrawUIso,
	366	const Standard_Boolean DrawVIso,
	367	const Quantity_Length Deflection,
	368	const Standard_Integer NBUiso,
	369	const Standard_Integer NBViso)
	370	{
	371
	372	StdPrs_ToolRFace ToolRst (aFace);
	373	const Standard_Real aLimit = aDrawer->MaximalParameterValue();
	374
	375	// compute bounds of the restriction
	376	Standard_Real UMin,UMax,VMin,VMax;
	377	Standard_Real u,v,step;
	378	Standard_Integer i,nbPoints = 10;
	379	UMin = VMin = RealLast();
	380	UMax = VMax = RealFirst();
	381
	382	for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
	383	Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
	384	u = TheRCurve->FirstParameter();
	385	v = TheRCurve->LastParameter();
	386	step = ( v - u) / nbPoints;
	387	for (i = 0; i <= nbPoints; i++) {
	388	gp_Pnt2d P = TheRCurve->Value(u);
	389	if (P.X() < UMin) UMin = P.X();
	390	if (P.X() > UMax) UMax = P.X();
	391	if (P.Y() < VMin) VMin = P.Y();
	392	if (P.Y() > VMax) VMax = P.Y();
	393	u += step;
	394	}
	395	}
	396
	397	// load the isos
	398	Hatch_Hatcher isobuild(1.e-5,ToolRst.IsOriented());
	399	Standard_Boolean UClosed = aFace->IsUClosed();
	400	Standard_Boolean VClosed = aFace->IsVClosed();
	401
	402	if ( ! UClosed ) {
	403	UMin = UMin + ( UMax - UMin) /1000.;
	404	UMax = UMax - ( UMax - UMin) /1000.;
	405	}
	406
407	if ( ! VClosed ) {
408	VMin = VMin + ( VMax - VMin) /1000.;
409	VMax = VMax - ( VMax - VMin) /1000.;
410	}
411
412	if (DrawUIso){
413	if (NBUiso > 0) {
414	UClosed = Standard_False; // En attendant un hatcher de course.
415	Standard_Real du= UClosed ? (UMax-UMin)/NBUiso : (UMax-UMin)/(1+NBUiso);
416	for (i=1; i<=NBUiso;i++){
417	isobuild.AddXLine(UMin+du*i);
418	}
419	}
420	}
421	if (DrawVIso){
422	if ( NBViso > 0) {
423	VClosed = Standard_False;
424	Standard_Real dv= VClosed ?(VMax-VMin)/NBViso : (VMax-VMin)/(1+NBViso);
425	for (i=1; i<=NBViso;i++){
426	isobuild.AddYLine(VMin+dv*i);
427	}
428	}
429	}
430
431	// trim the isos
432	gp_Pnt2d P1,P2;
433	gp_Pnt dummypnt;
434	for (ToolRst.Init(); ToolRst.More(); ToolRst.Next()) {
435	TopAbs_Orientation Orient = ToolRst.Orientation();
436	if ( Orient == TopAbs_FORWARD \|\| Orient == TopAbs_REVERSED ) {
437	Adaptor2d_Curve2dPtr TheRCurve = ToolRst.Value();
438	GCPnts_QuasiUniformDeflection UDP(*TheRCurve, Deflection);
439	if (UDP.IsDone()) {
440	Standard_Integer NumberOfPoints = UDP.NbPoints();
441	if ( NumberOfPoints >= 2 ) {
442	dummypnt = UDP.Value(1);
443	P2.SetCoord(dummypnt.X(), dummypnt.Y());
444	for (i = 2; i <= NumberOfPoints; i++) {
445	P1 = P2;
446	dummypnt = UDP.Value(i);
447	P2.SetCoord(dummypnt.X(), dummypnt.Y());
448	if(Orient == TopAbs_FORWARD )
449	isobuild.Trim(P1,P2);
450	else
451	isobuild.Trim(P2,P1);
452	}
453	}
454	}
455	else {
456	cout << "Cannot evaluate curve on surface"<<endl;
457	}
458	}
459	}
460
461	// draw the isos
462
463	Adaptor3d_IsoCurve anIso;
464	anIso.Load(aFace);
465	Standard_Integer NumberOfLines = isobuild.NbLines();
466	Standard_Real anAngle = aDrawer->DeviationAngle();
467
468	for (i = 1; i <= NumberOfLines; i++) {
469	Standard_Integer NumberOfIntervals = isobuild.NbIntervals(i);
470	Standard_Real Coord = isobuild.Coordinate(i);
471	for (Standard_Integer j = 1; j <= NumberOfIntervals; j++) {
472	Standard_Real b1=isobuild.Start(i,j),b2=isobuild.End(i,j);
473
474	b1 = b1 == RealFirst() ? - aLimit : b1;
475	b2 = b2 == RealLast() ? aLimit : b2;
476
477	if (isobuild.IsXLine(i))
478	anIso.Load(GeomAbs_IsoU,Coord,b1,b2);
479	else
480	anIso.Load(GeomAbs_IsoV,Coord,b1,b2);
481
482	if (StdPrs_DeflectionCurve::Match(X,Y,Z,aDistance,anIso, b1, b2, Deflection, anAngle))
483	return Standard_True;
484	}
485	}
486	return Standard_False;
487	}
488
489
490	//=========================================================================
491	// function: Add
492	// purpose
493	//=========================================================================
494	void StdPrs_WFDeflectionRestrictedFace::Add
495	(const Handle (Prs3d_Presentation)& aPresentation,
496	const Handle(BRepAdaptor_HSurface)& aFace,
b8ddfc2f	497	const Handle (Prs3d_Drawer)& aDrawer)
b8ddfc2f	498	{
7fd59977	499	Prs3d_NListOfSequenceOfPnt Curves;
	500	StdPrs_WFDeflectionRestrictedFace::Add (aPresentation,
	501	aFace,
	502	Standard_True,
	503	Standard_True,
b8ddfc2f	504	aDrawer->MaximalChordialDeviation(),
	505	aDrawer->UIsoAspect()->Number(),
	506	aDrawer->VIsoAspect()->Number(),
7fd59977	507	aDrawer,
7fd59977	508	Curves);
7fd59977	509	}
	510
	511
	512	//=========================================================================
	513	// function: AddUIso
	514	// purpose
	515	//=========================================================================
	516	void StdPrs_WFDeflectionRestrictedFace::AddUIso
	517	(const Handle (Prs3d_Presentation)& aPresentation,
	518	const Handle(BRepAdaptor_HSurface)& aFace,
b8ddfc2f	519	const Handle (Prs3d_Drawer)& aDrawer)
b8ddfc2f	520	{
7fd59977	521	Prs3d_NListOfSequenceOfPnt Curves;
	522	StdPrs_WFDeflectionRestrictedFace::Add (
	523	aPresentation,
	524	aFace,
	525	Standard_True,
	526	Standard_False,
b8ddfc2f	527	aDrawer->MaximalChordialDeviation(),
	528	aDrawer->UIsoAspect()->Number(),
	529	aDrawer->VIsoAspect()->Number(),
7fd59977	530	aDrawer,
	531	Curves);
	532	}
	533
	534
	535	//=========================================================================
	536	// function: AddVIso
	537	// purpose
	538	//=========================================================================
	539	void StdPrs_WFDeflectionRestrictedFace::AddVIso
	540	(const Handle (Prs3d_Presentation)& aPresentation,
	541	const Handle(BRepAdaptor_HSurface)& aFace,
b8ddfc2f	542	const Handle (Prs3d_Drawer)& aDrawer)
b8ddfc2f	543	{
7fd59977	544	Prs3d_NListOfSequenceOfPnt Curves;
	545	StdPrs_WFDeflectionRestrictedFace::Add (
	546	aPresentation,
	547	aFace,
	548	Standard_False,
	549	Standard_True,
b8ddfc2f	550	aDrawer->MaximalChordialDeviation(),
	551	aDrawer->UIsoAspect()->Number(),
	552	aDrawer->VIsoAspect()->Number(),
7fd59977	553	aDrawer,
	554	Curves);
	555	}
	556
	557
	558	//=========================================================================
	559	// function: Match
	560	// purpose
	561	//=========================================================================
	562	Standard_Boolean StdPrs_WFDeflectionRestrictedFace::Match
	563	(const Quantity_Length X,
	564	const Quantity_Length Y,
	565	const Quantity_Length Z,
	566	const Quantity_Length aDistance,
	567	const Handle(BRepAdaptor_HSurface)& aFace,
b8ddfc2f	568	const Handle (Prs3d_Drawer)& aDrawer)
b8ddfc2f	569	{
7fd59977	570	return StdPrs_WFDeflectionRestrictedFace::Match (
7fd59977	571	X,Y,Z,aDistance,
b8ddfc2f	572	aFace,
	573	aDrawer,
	574	Standard_True,
	575	Standard_True,
	576	aDrawer->MaximalChordialDeviation(),
	577	aDrawer->UIsoAspect()->Number(),
	578	aDrawer->VIsoAspect()->Number());
7fd59977	579	}
	580
	581
	582	//=========================================================================
	583	// function: MatchUIso
	584	// purpose
	585	//=========================================================================
	586	Standard_Boolean StdPrs_WFDeflectionRestrictedFace::MatchUIso
	587	(const Quantity_Length X,
	588	const Quantity_Length Y,
	589	const Quantity_Length Z,
	590	const Quantity_Length aDistance,
	591	const Handle(BRepAdaptor_HSurface)& aFace,
b8ddfc2f	592	const Handle (Prs3d_Drawer)& aDrawer)
b8ddfc2f	593	{
7fd59977	594	return StdPrs_WFDeflectionRestrictedFace::Match (
7fd59977	595	X,Y,Z,aDistance,
b8ddfc2f	596	aFace,
	597	aDrawer,
	598	Standard_True,
	599	Standard_False,
	600	aDrawer->MaximalChordialDeviation(),
	601	aDrawer->UIsoAspect()->Number(),
	602	aDrawer->VIsoAspect()->Number());
7fd59977	603	}
	604
	605
	606	//=========================================================================
	607	// function: MatchVIso
	608	// purpose
	609	//=========================================================================
	610	Standard_Boolean StdPrs_WFDeflectionRestrictedFace::MatchVIso
	611	(const Quantity_Length X,
	612	const Quantity_Length Y,
	613	const Quantity_Length Z,
	614	const Quantity_Length aDistance,
	615	const Handle(BRepAdaptor_HSurface)& aFace,
b8ddfc2f	616	const Handle (Prs3d_Drawer)& aDrawer)
b8ddfc2f	617	{
7fd59977	618	return StdPrs_WFDeflectionRestrictedFace::Match (
7fd59977	619	X,Y,Z,aDistance,
b8ddfc2f	620	aFace,
	621	aDrawer,
	622	Standard_False,
	623	Standard_True,
	624	aDrawer->MaximalChordialDeviation(),
	625	aDrawer->UIsoAspect()->Number(),
	626	aDrawer->VIsoAspect()->Number());
7fd59977	627	}