[occt.git] / src / IntCurve / IntCurve_IntConicConic_Tool.hxx

// Created on: 1992-05-06
// Created by: Laurent BUCHARD
// Copyright (c) 1992-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 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 IntCurve_IntConicConic_Tool_HeaderFile
#define IntCurve_IntConicConic_Tool_HeaderFile


#include <IntCurve_IntImpConicParConic.hxx>
#include <IntCurve_IConicTool.hxx>
#include <IntCurve_PConic.hxx>
// #include <IntCurve_IConicPConicTool.hxx>
#include <IntRes2d_Domain.hxx>
#include <IntRes2d_Transition.hxx>
#include <IntRes2d_Position.hxx>
#include <gp_Vec2d.hxx>
#include <gp.hxx>


static Standard_Real PIpPI = M_PI + M_PI;

//======================================================================
//==========          P R O T O T Y P E S                   ============
//======================================================================

void Determine_Transition_LC(const IntRes2d_Position,
			     gp_Vec2d&,
			     const gp_Vec2d&,
			     IntRes2d_Transition&,
			     const IntRes2d_Position,
			     gp_Vec2d&,
			     const gp_Vec2d&,
			     IntRes2d_Transition&,
			     const Standard_Real);
//======================================================================
Standard_Real NormalizeOnCircleDomain(const Standard_Real Param,const IntRes2d_Domain& Domain);
//=====================================================================
//====   C l a s s e     I n t e r v a l      !! Specifique !! ========
//=====================================================================
class Interval {
 public:
  Standard_Real Binf;
  Standard_Real Bsup;
  Standard_Boolean HasFirstBound;
  Standard_Boolean HasLastBound;
  Standard_Boolean IsNull;
  
  Interval();
  Interval(const Standard_Real a,const Standard_Real b);
  Interval(const IntRes2d_Domain& Domain);
  Interval( const Standard_Real a,const Standard_Boolean hf
	   ,const Standard_Real b,const Standard_Boolean hl);
  Standard_Real Length(); 
  Interval IntersectionWithBounded(const Interval& Inter);
};


//======================================================================
//==  C L A S S E    P E R I O D I C    I N T E R V A L  (Specifique)
//======================================================================
class PeriodicInterval {
 public:
  Standard_Real Binf;
  Standard_Real Bsup;
  Standard_Boolean isnull;

  void SetNull()      { isnull=Standard_True; }
  Standard_Boolean IsNull()    { return(isnull); }

  void Complement()   { if(!isnull) {
                          Standard_Real t=Binf; Binf=Bsup; Bsup=t+PIpPI;
			  if(Binf>PIpPI) {
			    Binf-=PIpPI;
			    Bsup-=PIpPI;
			  }
			}
		      }

  Standard_Real Length()       { return((isnull)? -100.0: Abs(Bsup-Binf)); }


  PeriodicInterval(const IntRes2d_Domain& Domain) {  
                        isnull=Standard_False;
                        if(Domain.HasFirstPoint())  
			  Binf=Domain.FirstParameter();
			else
			  Binf=-1.0;
			if(Domain.HasLastPoint()) 
			  Bsup=Domain.LastParameter();
			else
			  Bsup=20.0;
		      }
  PeriodicInterval()  { isnull=Standard_True; Binf=Bsup=0.0; }
  PeriodicInterval(const Standard_Real a,const Standard_Real b) 
                      {
			isnull=Standard_False;
			Binf=a;
			Bsup=b;
			if((b-a) < PIpPI)
			  this->Normalize();
		      }
  void SetValues(const Standard_Real a,const Standard_Real b)
                      {
			isnull=Standard_False;
			Binf=a;
			Bsup=b;
			if((b-a) < PIpPI)
			  this->Normalize();
		      }
  void Normalize() {
                   if(!isnull) {
		     while(Binf>PIpPI) Binf-=PIpPI;
		     while(Binf<0.0)   Binf+=PIpPI;
		     while(Bsup<Binf)  Bsup+=PIpPI;
		     while(Bsup>=(Binf+PIpPI)) Bsup-=PIpPI;
		   }
		 }
    
  PeriodicInterval FirstIntersection(PeriodicInterval& I1);
  PeriodicInterval SecondIntersection(PeriodicInterval& I2);
};


#endif
Commit	Line	Data
b311480e	1	// Created on: 1992-05-06
	2	// Created by: Laurent BUCHARD
	3	// Copyright (c) 1992-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	//
973c2be1	8	// This library is free software; you can redistribute it and / or modify it
	9	// under the terms of the GNU Lesser General Public version 2.1 as published
	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	#ifndef IntCurve_IntConicConic_Tool_HeaderFile
	18	#define IntCurve_IntConicConic_Tool_HeaderFile
	19
	20
	21	#include <IntCurve_IntImpConicParConic.hxx>
	22	#include <IntCurve_IConicTool.hxx>
	23	#include <IntCurve_PConic.hxx>
	24	// #include <IntCurve_IConicPConicTool.hxx>
	25	#include <IntRes2d_Domain.hxx>
	26	#include <IntRes2d_Transition.hxx>
	27	#include <IntRes2d_Position.hxx>
	28	#include <gp_Vec2d.hxx>
	29	#include <gp.hxx>
	30
	31
c6541a0c	32	static Standard_Real PIpPI = M_PI + M_PI;
7fd59977	33
	34	//======================================================================
	35	//========== P R O T O T Y P E S ============
	36	//======================================================================
	37
	38	void Determine_Transition_LC(const IntRes2d_Position,
	39	gp_Vec2d&,
	40	const gp_Vec2d&,
	41	IntRes2d_Transition&,
	42	const IntRes2d_Position,
	43	gp_Vec2d&,
	44	const gp_Vec2d&,
	45	IntRes2d_Transition&,
	46	const Standard_Real);
	47	//======================================================================
	48	Standard_Real NormalizeOnCircleDomain(const Standard_Real Param,const IntRes2d_Domain& Domain);
	49	//=====================================================================
	50	//==== C l a s s e I n t e r v a l !! Specifique !! ========
	51	//=====================================================================
	52	class Interval {
	53	public:
	54	Standard_Real Binf;
	55	Standard_Real Bsup;
	56	Standard_Boolean HasFirstBound;
	57	Standard_Boolean HasLastBound;
	58	Standard_Boolean IsNull;
	59
	60	Interval();
	61	Interval(const Standard_Real a,const Standard_Real b);
	62	Interval(const IntRes2d_Domain& Domain);
	63	Interval( const Standard_Real a,const Standard_Boolean hf
	64	,const Standard_Real b,const Standard_Boolean hl);
	65	Standard_Real Length();
	66	Interval IntersectionWithBounded(const Interval& Inter);
	67	};
	68
	69
	70
	71	//======================================================================
	72	//== C L A S S E P E R I O D I C I N T E R V A L (Specifique)
	73	//======================================================================
	74	class PeriodicInterval {
	75	public:
	76	Standard_Real Binf;
	77	Standard_Real Bsup;
	78	Standard_Boolean isnull;
	79
	80	void SetNull() { isnull=Standard_True; }
	81	Standard_Boolean IsNull() { return(isnull); }
	82
	83	void Complement() { if(!isnull) {
	84	Standard_Real t=Binf; Binf=Bsup; Bsup=t+PIpPI;
	85	if(Binf>PIpPI) {
	86	Binf-=PIpPI;
	87	Bsup-=PIpPI;
	88	}
	89	}
	90	}
	91
	92	Standard_Real Length() { return((isnull)? -100.0: Abs(Bsup-Binf)); }
	93
	94
	95	PeriodicInterval(const IntRes2d_Domain& Domain) {
	96	isnull=Standard_False;
97	if(Domain.HasFirstPoint())
98	Binf=Domain.FirstParameter();
99	else
100	Binf=-1.0;
101	if(Domain.HasLastPoint())
102	Bsup=Domain.LastParameter();
103	else
104	Bsup=20.0;
105	}
106	PeriodicInterval() { isnull=Standard_True; Binf=Bsup=0.0; }
107	PeriodicInterval(const Standard_Real a,const Standard_Real b)
108	{
109	isnull=Standard_False;
110	Binf=a;
111	Bsup=b;
112	if((b-a) < PIpPI)
113	this->Normalize();
114	}
115	void SetValues(const Standard_Real a,const Standard_Real b)
116	{
117	isnull=Standard_False;
118	Binf=a;
119	Bsup=b;
120	if((b-a) < PIpPI)
121	this->Normalize();
122	}
123	void Normalize() {
124	if(!isnull) {
125	while(Binf>PIpPI) Binf-=PIpPI;
126	while(Binf<0.0) Binf+=PIpPI;
127	while(Bsup<Binf) Bsup+=PIpPI;
128	while(Bsup>=(Binf+PIpPI)) Bsup-=PIpPI;
129	}
130	}
131
132	PeriodicInterval FirstIntersection(PeriodicInterval& I1);
133	PeriodicInterval SecondIntersection(PeriodicInterval& I2);
134	};
135
136
137	#endif