[occt.git] / src / CSLib / CSLib_Class2d.cxx

// Created on: 1995-03-08
// Created by: Laurent BUCHARD
// 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.

//#define No_Standard_OutOfRange

#include <CSLib_Class2d.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_ConstructionError.hxx>

static inline 
  Standard_Real Transform2d(const Standard_Real u,
			    const Standard_Real umin,
			    const Standard_Real umaxmumin);

//=======================================================================
//function : Init
//purpose  :
//=======================================================================
template <class TCol_Containers2d>
void CSLib_Class2d::Init(const TCol_Containers2d& TP2d,
                 const Standard_Real aTolu,
                 const Standard_Real aTolv,
                 const Standard_Real umin,
                 const Standard_Real vmin,
                 const Standard_Real umax,
                 const Standard_Real vmax)
{
  Umin = umin;
  Vmin = vmin;
  Umax = umax;
  Vmax = vmax;
  //
  if ((umax <= umin) || (vmax <= vmin) || (TP2d.Length() < 3))
  {
    MyPnts2dX.Nullify();
    MyPnts2dY.Nullify();
    N = 0;
  }
  //
  else
  {
    Standard_Integer i, iLower;
    Standard_Real du, dv, aPrc;
    //
    aPrc = 1.e-10;
    N = TP2d.Length();
    Tolu = aTolu;
    Tolv = aTolv;
    MyPnts2dX = new TColStd_Array1OfReal(0, N);
    MyPnts2dY = new TColStd_Array1OfReal(0, N);
    du = umax - umin;
    dv = vmax - vmin;
    //
    iLower = TP2d.Lower();
    for (i = 0; i<N; ++i)
    {
      const gp_Pnt2d& aP2D = TP2d(i + iLower);
      MyPnts2dX->ChangeValue(i) = Transform2d(aP2D.X(), umin, du);
      MyPnts2dY->ChangeValue(i) = Transform2d(aP2D.Y(), vmin, dv);
    }
    MyPnts2dX->ChangeLast() = MyPnts2dX->First();
    MyPnts2dY->ChangeLast() = MyPnts2dY->First();
    //
    if (du>aPrc)
    {
      Tolu /= du;
    }
    if (dv>aPrc)
    {
      Tolv /= dv;
    }
  }
}

//=======================================================================
//function : CSLib_Class2d
//purpose  : 
//=======================================================================
CSLib_Class2d::CSLib_Class2d(const TColgp_Array1OfPnt2d& thePnts2d,
                             const Standard_Real theTolU,
                             const Standard_Real theTolV,
                             const Standard_Real theUMin,
                             const Standard_Real theVMin,
                             const Standard_Real theUMax,
                             const Standard_Real theVMax)
{
  Init(thePnts2d, theTolU, theTolV, theUMin,
       theVMin, theUMax, theVMax);
}

//=======================================================================
//function : CSLib_Class2d
//purpose  : 
//=======================================================================
CSLib_Class2d::CSLib_Class2d(const TColgp_SequenceOfPnt2d& thePnts2d,
                             const Standard_Real theTolU,
                             const Standard_Real theTolV,
                             const Standard_Real theUMin,
                             const Standard_Real theVMin,
                             const Standard_Real theUMax,
                             const Standard_Real theVMax)
{
  Init(thePnts2d, theTolU, theTolV, theUMin,
       theVMin, theUMax, theVMax);
}

//=======================================================================
//function : SiDans
//purpose  : 
//=======================================================================
Standard_Integer CSLib_Class2d::SiDans(const gp_Pnt2d& P) const
{ 
  if(!N) {
    return 0;
  }
  //
  Standard_Real x,y, aTolu, aTolv;
  //
  x = P.X(); y = P.Y();
  aTolu=Tolu*(Umax-Umin);
  aTolv=Tolv*(Vmax-Vmin);
  //
  if(Umin<Umax && Vmin<Vmax)    {
    if( ( x<(Umin-aTolu) ) || 
       ( x>(Umax+aTolu) ) || 
       ( y<(Vmin-aTolv) ) || 
       ( y>(Vmax+aTolv) ) ) {
      return -1;
    }
    x=Transform2d(x,Umin,Umax-Umin);
    y=Transform2d(y,Vmin,Vmax-Vmin);
  }


  Standard_Integer res = InternalSiDansOuOn(x,y);
  if(res==-1) {    
    return 0;
  }
  if(Tolu || Tolv) {
    if(res != InternalSiDans(x-Tolu,y-Tolv)) return 0;
    if(res != InternalSiDans(x+Tolu,y-Tolv)) return 0;
    if(res != InternalSiDans(x-Tolu,y+Tolv)) return 0;
    if(res != InternalSiDans(x+Tolu,y+Tolv)) return 0; 
  }
  //
  return((res)? 1: -1);
}
//=======================================================================
//function : SiDans_OnMode
//purpose  : 
//=======================================================================
Standard_Integer CSLib_Class2d::SiDans_OnMode(const gp_Pnt2d& P,
					      const Standard_Real Tol) const
{ 
  if(!N){
    return 0;
  }
  //
  Standard_Real x,y, aTolu, aTolv;
  //
  x = P.X(); y = P.Y();
  aTolu=Tol; 
  aTolv=Tol; 

  //-- ****** TO DO LATER, ESTIMATE AT EACH POINT Tol2d depending on Tol3d *****
  if(Umin<Umax && Vmin<Vmax) { 
    if(x<(Umin-aTolu) || (x>Umax+aTolu) || 
       (y<Vmin-aTolv) || (y>Vmax+aTolv)) {
      return -1;
    }
    x=Transform2d(x,Umin,Umax-Umin);
    y=Transform2d(y,Vmin,Vmax-Vmin);
  }
  //
  Standard_Integer res = InternalSiDansOuOn(x,y);
  if(aTolu || aTolv) {
    if(res != InternalSiDans(x-aTolu,y-aTolv)) return 0;
    if(res != InternalSiDans(x+aTolu,y-aTolv)) return 0;
    if(res != InternalSiDans(x-aTolu,y+aTolv)) return 0;
    if(res != InternalSiDans(x+aTolu,y+aTolv)) return 0; 
  }
  return((res)? 1: -1);
}
//=======================================================================
//function : InternalSiDans
//purpose  : 
//=======================================================================
Standard_Integer CSLib_Class2d::InternalSiDans(const Standard_Real Px,
					       const Standard_Real Py) const
{ 
  Standard_Integer nbc, i, ip1, SH, NH;
  Standard_Real  x, y, nx, ny;
  //
  nbc = 0;
  i   = 0;
  ip1 = 1;
  x   = (MyPnts2dX->Value(i)-Px);
  y   = (MyPnts2dY->Value(i)-Py);
  SH  = (y<0.)? -1 : 1;
  //
  for(i=0; i<N ; i++,ip1++) { 
    nx = MyPnts2dX->Value(ip1) - Px;
    ny = MyPnts2dY->Value(ip1) - Py;
    
    NH = (ny<0.)? -1 : 1;
    if(NH!=SH) { 
      if(x>0. && nx>0.) {
	nbc++;
      }
      else { 
	if(x>0.0 || nx>0.) { 
	  if((x-y*(nx-x)/(ny-y))>0.) {
	    nbc++;
	  }
	}
      }
      SH = NH;
    }
    x = nx; y = ny;
  }
  return(nbc&1);
}
//modified by NIZNHY-PKV Fri Jan 15 09:03:48 2010f
//=======================================================================
//function : InternalSiDansOuOn
//purpose  : same code as above + test on ON (return(-1) in this case
//=======================================================================
Standard_Integer CSLib_Class2d::InternalSiDansOuOn(const Standard_Real Px,
						   const Standard_Real Py) const 
{ 
  Standard_Integer nbc, i, ip1, SH, NH, iRet;
  Standard_Real x, y, nx, ny, aX;
  Standard_Real aYmin;
  //
  nbc = 0;
  i   = 0;
  ip1 = 1;
  x   = (MyPnts2dX->Value(i)-Px);
  y   = (MyPnts2dY->Value(i)-Py);
  aYmin=y;
  SH  = (y<0.)? -1 : 1;
  for(i=0; i<N ; i++, ip1++) { 
   
    nx = MyPnts2dX->Value(ip1) - Px;
    ny = MyPnts2dY->Value(ip1) - Py;
    //-- le 14 oct 97 
    if(nx<Tolu && nx>-Tolu && ny<Tolv && ny>-Tolv) { 
      iRet=-1;
      return iRet;
    }
    //find Y coordinate of polyline for current X gka
    //in order to detect possible status ON
    Standard_Real aDx = (MyPnts2dX->Value(ip1) - MyPnts2dX->Value(ip1-1));
    if( (MyPnts2dX->Value(ip1-1) - Px) * nx < 0.)
    {
     
      Standard_Real aCurPY = MyPnts2dY->Value(ip1) - (MyPnts2dY->Value(ip1) - MyPnts2dY->Value(ip1-1))/aDx *nx;
      Standard_Real aDeltaY = aCurPY - Py;
      if(aDeltaY >= -Tolv && aDeltaY <= Tolv)
      {
         iRet=-1;
         return iRet;
      }
    }
    //
      
    NH = (ny<0.)? -1 : 1;
    if(NH!=SH) { 
      if(x>0. && nx>0.) {
	nbc++;
      }
      else { 
	if(x>0. || nx>0.) { 
	  aX=x-y*(nx-x)/(ny-y);
	  if(aX>0.){
	    nbc++;
	  }
	}
      }
      SH = NH;
    }
    else {// y has same sign as ny  
      if (ny<aYmin) {
	aYmin=ny;
      }
    }
    x = nx; y = ny; 
  }// for(i=0; i<N ; i++,ip1++) { 
 
  iRet=nbc&1;
  return iRet;
}
//modified by NIZNHY-PKV Fri Jan 15 09:03:55 2010t
//=======================================================================
//function : Transform2d
//purpose  : 
//=======================================================================
Standard_Real Transform2d(const Standard_Real u,
			  const Standard_Real umin,
			  const Standard_Real umaxmumin) 
{ 
  if(umaxmumin>1e-10) { 
    Standard_Real U = (u-umin)/umaxmumin;
    return U;
  }
  else { 
    return u;
  }
}
Commit	Line	Data
b311480e	1	// Created on: 1995-03-08
	2	// Created by: Laurent BUCHARD
	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	//#define No_Standard_OutOfRange
	18
42cf5bc1	19	#include <CSLib_Class2d.hxx>
42cf5bc1	20	#include <gp_Pnt2d.hxx>
7fd59977	21	#include <Standard_ConstructionError.hxx>
	22
	23	static inline
	24	Standard_Real Transform2d(const Standard_Real u,
	25	const Standard_Real umin,
	26	const Standard_Real umaxmumin);
	27
	28	//=======================================================================
5fe14d0f	29	//function : Init
5fe14d0f	30	//purpose :
7fd59977	31	//=======================================================================
5fe14d0f	32	template <class TCol_Containers2d>
	33	void CSLib_Class2d::Init(const TCol_Containers2d& TP2d,
	34	const Standard_Real aTolu,
	35	const Standard_Real aTolv,
	36	const Standard_Real umin,
	37	const Standard_Real vmin,
	38	const Standard_Real umax,
	39	const Standard_Real vmax)
7fd59977	40	{
5fe14d0f	41	Umin = umin;
	42	Vmin = vmin;
	43	Umax = umax;
	44	Vmax = vmax;
7fd59977	45	//
5fe14d0f	46	if ((umax <= umin) \|\| (vmax <= vmin) \|\| (TP2d.Length() < 3))
	47	{
	48	MyPnts2dX.Nullify();
	49	MyPnts2dY.Nullify();
	50	N = 0;
7fd59977	51	}
7fd59977	52	//
5fe14d0f	53	else
5fe14d0f	54	{
7fd59977	55	Standard_Integer i, iLower;
5fe14d0f	56	Standard_Real du, dv, aPrc;
7fd59977	57	//
5fe14d0f	58	aPrc = 1.e-10;
7fd59977	59	N = TP2d.Length();
	60	Tolu = aTolu;
	61	Tolv = aTolv;
5fe14d0f	62	MyPnts2dX = new TColStd_Array1OfReal(0, N);
	63	MyPnts2dY = new TColStd_Array1OfReal(0, N);
	64	du = umax - umin;
	65	dv = vmax - vmin;
7fd59977	66	//
5fe14d0f	67	iLower = TP2d.Lower();
	68	for (i = 0; i<N; ++i)
	69	{
	70	const gp_Pnt2d& aP2D = TP2d(i + iLower);
	71	MyPnts2dX->ChangeValue(i) = Transform2d(aP2D.X(), umin, du);
	72	MyPnts2dY->ChangeValue(i) = Transform2d(aP2D.Y(), vmin, dv);
7fd59977	73	}
5fe14d0f	74	MyPnts2dX->ChangeLast() = MyPnts2dX->First();
5fe14d0f	75	MyPnts2dY->ChangeLast() = MyPnts2dY->First();
7fd59977	76	//
5fe14d0f	77	if (du>aPrc)
	78	{
	79	Tolu /= du;
7fd59977	80	}
5fe14d0f	81	if (dv>aPrc)
	82	{
	83	Tolv /= dv;
7fd59977	84	}
	85	}
	86	}
5fe14d0f	87
7fd59977	88	//=======================================================================
5fe14d0f	89	//function : CSLib_Class2d
7fd59977	90	//purpose :
7fd59977	91	//=======================================================================
5fe14d0f	92	CSLib_Class2d::CSLib_Class2d(const TColgp_Array1OfPnt2d& thePnts2d,
	93	const Standard_Real theTolU,
	94	const Standard_Real theTolV,
	95	const Standard_Real theUMin,
	96	const Standard_Real theVMin,
	97	const Standard_Real theUMax,
	98	const Standard_Real theVMax)
	99	{
	100	Init(thePnts2d, theTolU, theTolV, theUMin,
	101	theVMin, theUMax, theVMax);
	102	}
	103
	104	//=======================================================================
	105	//function : CSLib_Class2d
	106	//purpose :
	107	//=======================================================================
	108	CSLib_Class2d::CSLib_Class2d(const TColgp_SequenceOfPnt2d& thePnts2d,
	109	const Standard_Real theTolU,
	110	const Standard_Real theTolV,
	111	const Standard_Real theUMin,
	112	const Standard_Real theVMin,
	113	const Standard_Real theUMax,
	114	const Standard_Real theVMax)
	115	{
	116	Init(thePnts2d, theTolU, theTolV, theUMin,
	117	theVMin, theUMax, theVMax);
7fd59977	118	}
7fd59977	119
7fd59977	120	//=======================================================================
	121	//function : SiDans
	122	//purpose :
	123	//=======================================================================
	124	Standard_Integer CSLib_Class2d::SiDans(const gp_Pnt2d& P) const
	125	{
	126	if(!N) {
	127	return 0;
	128	}
	129	//
	130	Standard_Real x,y, aTolu, aTolv;
	131	//
	132	x = P.X(); y = P.Y();
	133	aTolu=Tolu*(Umax-Umin);
	134	aTolv=Tolv*(Vmax-Vmin);
	135	//
	136	if(Umin<Umax && Vmin<Vmax) {
	137	if( ( x<(Umin-aTolu) ) \|\|
	138	( x>(Umax+aTolu) ) \|\|
	139	( y<(Vmin-aTolv) ) \|\|
	140	( y>(Vmax+aTolv) ) ) {
	141	return -1;
	142	}
	143	x=Transform2d(x,Umin,Umax-Umin);
	144	y=Transform2d(y,Vmin,Vmax-Vmin);
	145	}
	146
	147
	148	Standard_Integer res = InternalSiDansOuOn(x,y);
0d969553	149	if(res==-1) {
7fd59977	150	return 0;
	151	}
	152	if(Tolu \|\| Tolv) {
	153	if(res != InternalSiDans(x-Tolu,y-Tolv)) return 0;
	154	if(res != InternalSiDans(x+Tolu,y-Tolv)) return 0;
	155	if(res != InternalSiDans(x-Tolu,y+Tolv)) return 0;
	156	if(res != InternalSiDans(x+Tolu,y+Tolv)) return 0;
	157	}
	158	//
	159	return((res)? 1: -1);
	160	}
	161	//=======================================================================
	162	//function : SiDans_OnMode
	163	//purpose :
	164	//=======================================================================
	165	Standard_Integer CSLib_Class2d::SiDans_OnMode(const gp_Pnt2d& P,
	166	const Standard_Real Tol) const
	167	{
	168	if(!N){
	169	return 0;
	170	}
	171	//
	172	Standard_Real x,y, aTolu, aTolv;
	173	//
	174	x = P.X(); y = P.Y();
	175	aTolu=Tol;
	176	aTolv=Tol;
	177
0d969553	178	//-- **** TO DO LATER, ESTIMATE AT EACH POINT Tol2d depending on Tol3d ***
7fd59977	179	if(Umin<Umax && Vmin<Vmax) {
	180	if(x<(Umin-aTolu) \|\| (x>Umax+aTolu) \|\|
	181	(y<Vmin-aTolv) \|\| (y>Vmax+aTolv)) {
	182	return -1;
	183	}
	184	x=Transform2d(x,Umin,Umax-Umin);
	185	y=Transform2d(y,Vmin,Vmax-Vmin);
	186	}
	187	//
	188	Standard_Integer res = InternalSiDansOuOn(x,y);
	189	if(aTolu \|\| aTolv) {
	190	if(res != InternalSiDans(x-aTolu,y-aTolv)) return 0;
	191	if(res != InternalSiDans(x+aTolu,y-aTolv)) return 0;
	192	if(res != InternalSiDans(x-aTolu,y+aTolv)) return 0;
	193	if(res != InternalSiDans(x+aTolu,y+aTolv)) return 0;
	194	}
	195	return((res)? 1: -1);
	196	}
	197	//=======================================================================
	198	//function : InternalSiDans
	199	//purpose :
	200	//=======================================================================
	201	Standard_Integer CSLib_Class2d::InternalSiDans(const Standard_Real Px,
	202	const Standard_Real Py) const
	203	{
	204	Standard_Integer nbc, i, ip1, SH, NH;
7fd59977	205	Standard_Real x, y, nx, ny;
	206	//
	207	nbc = 0;
	208	i = 0;
	209	ip1 = 1;
5fe14d0f	210	x = (MyPnts2dX->Value(i)-Px);
5fe14d0f	211	y = (MyPnts2dY->Value(i)-Py);
7fd59977	212	SH = (y<0.)? -1 : 1;
	213	//
	214	for(i=0; i<N ; i++,ip1++) {
5fe14d0f	215	nx = MyPnts2dX->Value(ip1) - Px;
5fe14d0f	216	ny = MyPnts2dY->Value(ip1) - Py;
7fd59977	217
	218	NH = (ny<0.)? -1 : 1;
	219	if(NH!=SH) {
	220	if(x>0. && nx>0.) {
	221	nbc++;
	222	}
	223	else {
	224	if(x>0.0 \|\| nx>0.) {
	225	if((x-y*(nx-x)/(ny-y))>0.) {
	226	nbc++;
	227	}
	228	}
	229	}
	230	SH = NH;
	231	}
	232	x = nx; y = ny;
	233	}
	234	return(nbc&1);
	235	}
	236	//modified by NIZNHY-PKV Fri Jan 15 09:03:48 2010f
	237	//=======================================================================
	238	//function : InternalSiDansOuOn
0d969553	239	//purpose : same code as above + test on ON (return(-1) in this case
7fd59977	240	//=======================================================================
	241	Standard_Integer CSLib_Class2d::InternalSiDansOuOn(const Standard_Real Px,
	242	const Standard_Real Py) const
	243	{
	244	Standard_Integer nbc, i, ip1, SH, NH, iRet;
7fd59977	245	Standard_Real x, y, nx, ny, aX;
96a95605	246	Standard_Real aYmin;
7fd59977	247	//
7fd59977	248	nbc = 0;
	249	i = 0;
	250	ip1 = 1;
5fe14d0f	251	x = (MyPnts2dX->Value(i)-Px);
5fe14d0f	252	y = (MyPnts2dY->Value(i)-Py);
7fd59977	253	aYmin=y;
	254	SH = (y<0.)? -1 : 1;
	255	for(i=0; i<N ; i++, ip1++) {
	256
5fe14d0f	257	nx = MyPnts2dX->Value(ip1) - Px;
5fe14d0f	258	ny = MyPnts2dY->Value(ip1) - Py;
7fd59977	259	//-- le 14 oct 97
	260	if(nx<Tolu && nx>-Tolu && ny<Tolv && ny>-Tolv) {
	261	iRet=-1;
	262	return iRet;
	263	}
	264	//find Y coordinate of polyline for current X gka
	265	//in order to detect possible status ON
5fe14d0f	266	Standard_Real aDx = (MyPnts2dX->Value(ip1) - MyPnts2dX->Value(ip1-1));
5fe14d0f	267	if( (MyPnts2dX->Value(ip1-1) - Px) * nx < 0.)
7fd59977	268	{
7fd59977	269
5fe14d0f	270	Standard_Real aCurPY = MyPnts2dY->Value(ip1) - (MyPnts2dY->Value(ip1) - MyPnts2dY->Value(ip1-1))/aDx *nx;
7fd59977	271	Standard_Real aDeltaY = aCurPY - Py;
	272	if(aDeltaY >= -Tolv && aDeltaY <= Tolv)
	273	{
	274	iRet=-1;
	275	return iRet;
	276	}
	277	}
	278	//
	279
	280	NH = (ny<0.)? -1 : 1;
	281	if(NH!=SH) {
	282	if(x>0. && nx>0.) {
	283	nbc++;
	284	}
	285	else {
	286	if(x>0. \|\| nx>0.) {
	287	aX=x-y*(nx-x)/(ny-y);
	288	if(aX>0.){
	289	nbc++;
	290	}
	291	}
	292	}
	293	SH = NH;
	294	}
	295	else {// y has same sign as ny
	296	if (ny<aYmin) {
	297	aYmin=ny;
	298	}
	299	}
	300	x = nx; y = ny;
	301	}// for(i=0; i<N ; i++,ip1++) {
	302
	303	iRet=nbc&1;
	304	return iRet;
	305	}
	306	//modified by NIZNHY-PKV Fri Jan 15 09:03:55 2010t
	307	//=======================================================================
7fd59977	308	//function : Transform2d
	309	//purpose :
	310	//=======================================================================
	311	Standard_Real Transform2d(const Standard_Real u,
	312	const Standard_Real umin,
	313	const Standard_Real umaxmumin)
	314	{
	315	if(umaxmumin>1e-10) {
	316	Standard_Real U = (u-umin)/umaxmumin;
	317	return U;
	318	}
	319	else {
	320	return u;
	321	}
	322	}