[occt.git] / src / Bnd / Bnd_Box2d.cxx

// Created on: 1991-10-30
// Created by: Modelisation
// Copyright (c) 1991-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 <Bnd_Box2d.hxx>
#include <gp.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_Stream.hxx>

//-- #include <Precision.hxx> Precision::Infinite() -> 1e+100
//=======================================================================
//function : Update
//purpose  : 
//=======================================================================
void Bnd_Box2d::Update (const Standard_Real x, const Standard_Real y, 
			const Standard_Real X, const Standard_Real Y)
{
  if (Flags & VoidMask) {
    Xmin = x;
    Ymin = y;
    Xmax = X;
    Ymax = Y;
    Flags &= ~VoidMask;
  }
  else {
    if (!(Flags & XminMask) && (x < Xmin)) Xmin = x;
    if (!(Flags & XmaxMask) && (X > Xmax)) Xmax = X;
    if (!(Flags & YminMask) && (y < Ymin)) Ymin = y;
    if (!(Flags & YmaxMask) && (Y > Ymax)) Ymax = Y;
  }
}

//=======================================================================
//function : Update
//purpose  : 
//=======================================================================

void Bnd_Box2d::Update (const Standard_Real X, const Standard_Real Y)
{
  if (Flags & VoidMask) {
    Xmin = X;
    Ymin = Y;
    Xmax = X;
    Ymax = Y;
    Flags &= ~VoidMask;
  }
  else {
    if      (!(Flags & XminMask) && (X < Xmin)) Xmin = X;
    else if (!(Flags & XmaxMask) && (X > Xmax)) Xmax = X;
    if      (!(Flags & YminMask) && (Y < Ymin)) Ymin = Y;
    else if (!(Flags & YmaxMask) && (Y > Ymax)) Ymax = Y;
  }
}

//=======================================================================
//function : Get
//purpose  : 
//=======================================================================

void Bnd_Box2d::Get (Standard_Real& x, Standard_Real& y,
		     Standard_Real& Xm, Standard_Real& Ym) const
{
  if(Flags & VoidMask)
    Standard_ConstructionError::Raise("Bnd_Box is void");
  Standard_Real pinf = 1e+100; //-- Precision::Infinite();
  if (Flags & XminMask) x = -pinf;
  else                  x =  Xmin-Gap;
  if (Flags & XmaxMask) Xm =  pinf;
  else                  Xm =  Xmax+Gap;
  if (Flags & YminMask) y = -pinf;
  else                  y =  Ymin-Gap;
  if (Flags & YmaxMask) Ym =  pinf;
  else                  Ym =  Ymax+Gap;
}

//=======================================================================
//function : Transformed
//purpose  : 
//=======================================================================

Bnd_Box2d Bnd_Box2d::Transformed (const gp_Trsf2d& T) const
{
  gp_TrsfForm F = T.Form();
  Bnd_Box2d newb(*this);
  if ( IsVoid() ) return newb;

  if      (F == gp_Identity) {}
  else if (F == gp_Translation) {
    Standard_Real DX,DY;
    (T.TranslationPart()).Coord(DX,DY);
    if (!(Flags & XminMask))  newb.Xmin += DX;
    if (!(Flags & XmaxMask))  newb.Xmax += DX;
    if (!(Flags & YminMask))  newb.Ymin += DY;
    if (!(Flags & YmaxMask))  newb.Ymax += DY;
  }
  else {
    gp_Pnt2d P[4];
    Standard_Boolean Vertex[4];
    Standard_Integer i;
    Vertex[0] = Standard_True;
    Vertex[1] = Standard_True;
    Vertex[2] = Standard_True;
    Vertex[3] = Standard_True;
    gp_Dir2d D[6];
//    Standard_Integer vertices = 0;
    Standard_Integer directions = 0;

    if (Flags & XminMask) {
      D[directions].SetCoord(-1., 0.);
      directions++;
      Vertex[0] = Vertex[2] = Standard_False;
    }
    if (Flags & XmaxMask) {
      D[directions].SetCoord( 1., 0.);
      directions++;
      Vertex[1] = Vertex[3] = Standard_False;
    }
    if (Flags & YminMask) {
      D[directions].SetCoord( 0.,-1.);
      directions++;
      Vertex[0] = Vertex[1] = Standard_False;
    }
    if (Flags & YmaxMask) {
      D[directions].SetCoord( 0., 1.);
      directions++;
      Vertex[2] = Vertex[3] = Standard_False;
    }

    newb.SetVoid();

    for (i = 0; i < directions; i++) {
      D[i].Transform(T);
      newb.Add(D[i]);
    }
    P[0].SetCoord(Xmin,Ymin);
    P[1].SetCoord(Xmax,Ymin);
    P[2].SetCoord(Xmin,Ymax);
    P[3].SetCoord(Xmax,Ymax);
    if (Vertex[0]) {
      P[0].Transform(T);
      newb.Add(P[0]);
    }
    if (Vertex[1]) {
      P[1].Transform(T);
      newb.Add(P[1]);
    }
    if (Vertex[2]) {
      P[2].Transform(T);
      newb.Add(P[2]);
    }
    if (Vertex[3]) {
      P[3].Transform(T);
      newb.Add(P[3]);
    }
    newb.Gap=Gap;
  }
  return newb;
}

//=======================================================================
//function : Add
//purpose  : 
//=======================================================================

void Bnd_Box2d::Add (const Bnd_Box2d& Other)
{
  if (IsWhole()) return;
  else if (Other.IsVoid()) return; 
  else if (Other.IsWhole()) SetWhole();
  else if (IsVoid()) (*this) = Other;
  else
  {
    if ( ! IsOpenXmin() )
    {
      if (Other.IsOpenXmin()) OpenXmin();
      else if (Xmin > Other.Xmin) Xmin = Other.Xmin;
    }
    if ( ! IsOpenXmax() )
    {
      if (Other.IsOpenXmax()) OpenXmax();
      else if (Xmax < Other.Xmax) Xmax = Other.Xmax;
    }
    if ( ! IsOpenYmin() )
    {
      if (Other.IsOpenYmin()) OpenYmin();
      else if (Ymin > Other.Ymin) Ymin = Other.Ymin;
    }
    if ( ! IsOpenYmax() )
    {
      if (Other.IsOpenYmax()) OpenYmax();
      else if (Ymax < Other.Ymax) Ymax = Other.Ymax;
    }
    Gap = Max (Gap, Other.Gap);
  }
}

//=======================================================================
//function : Add
//purpose  : 
//=======================================================================

void Bnd_Box2d::Add (const gp_Dir2d& D)
{
  Standard_Real DX = D.X();
  Standard_Real DY = D.Y();

  if (DX < -RealEpsilon()) 
    OpenXmin();
  else if (DX > RealEpsilon()) 
    OpenXmax();

  if (DY < -RealEpsilon())
    OpenYmin();
  else if (DY > RealEpsilon())
    OpenYmax();
}

//=======================================================================
//function : IsOut
//purpose  : 
//=======================================================================

Standard_Boolean Bnd_Box2d::IsOut (const gp_Pnt2d& P) const
{
  if        (IsWhole())  return Standard_False;
  else if   (IsVoid())   return Standard_True;
  else {
    Standard_Real X = P.X();
    Standard_Real Y = P.Y();
    if      (!(Flags & XminMask) && (X < (Xmin-Gap))) return Standard_True;
    else if (!(Flags & XmaxMask) && (X > (Xmax+Gap))) return Standard_True;
    else if (!(Flags & YminMask) && (Y < (Ymin-Gap))) return Standard_True;
    else if (!(Flags & YmaxMask) && (Y > (Ymax+Gap))) return Standard_True;
    else return Standard_False;
  }
}

//=======================================================================
//function : IsOut
//purpose  : 
//=======================================================================

Standard_Boolean Bnd_Box2d::IsOut (const Bnd_Box2d& Other) const
{
  if        (IsWhole())  return Standard_False;
  else if   (IsVoid())   return Standard_True;
  else if   (Other.IsWhole())  return Standard_False;
  else if   (Other.IsVoid())   return Standard_True;
  else {
    Standard_Real OXmin,OXmax,OYmin,OYmax;
    Other.Get(OXmin,OYmin,OXmax,OYmax);
    if      (!(Flags & XminMask) && (OXmax < (Xmin-Gap))) return Standard_True;
    else if (!(Flags & XmaxMask) && (OXmin > (Xmax+Gap))) return Standard_True;
    else if (!(Flags & YminMask) && (OYmax < (Ymin-Gap))) return Standard_True;
    else if (!(Flags & YmaxMask) && (OYmin > (Ymax+Gap))) return Standard_True;
  }
  return Standard_False;
}

//=======================================================================
//function : Dump
//purpose  : 
//=======================================================================

void Bnd_Box2d::Dump () const
{
  cout << "Box2d : ";
  if      (IsVoid())  cout << "Void";
  else if (IsWhole()) cout << "Whole";
  else {
    cout << "\n Xmin : ";
    if (IsOpenXmin()) cout << "Infinite";
    else              cout << Xmin;
    cout << "\n Xmax : ";
    if (IsOpenXmax()) cout << "Infinite";
    else              cout << Xmax;
    cout << "\n Ymin : ";
    if (IsOpenYmin()) cout << "Infinite";
    else              cout << Ymin;
    cout << "\n Ymax : ";
    if (IsOpenYmax()) cout << "Infinite";
    else              cout << Ymax;
  }
  cout << "\n Gap : " << Gap;
  cout << "\n";
}
Commit	Line	Data
b311480e	1	// Created on: 1991-10-30
	2	// Created by: Modelisation
	3	// Copyright (c) 1991-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
42cf5bc1	17
42cf5bc1	18	#include <Bnd_Box2d.hxx>
7fd59977	19	#include <gp.hxx>
42cf5bc1	20	#include <gp_Dir2d.hxx>
	21	#include <gp_Pnt2d.hxx>
	22	#include <gp_Trsf2d.hxx>
	23	#include <Standard_ConstructionError.hxx>
	24	#include <Standard_Stream.hxx>
7fd59977	25
42cf5bc1	26	//-- #include <Precision.hxx> Precision::Infinite() -> 1e+100
7fd59977	27	//=======================================================================
	28	//function : Update
	29	//purpose :
	30	//=======================================================================
7fd59977	31	void Bnd_Box2d::Update (const Standard_Real x, const Standard_Real y,
	32	const Standard_Real X, const Standard_Real Y)
	33	{
	34	if (Flags & VoidMask) {
	35	Xmin = x;
	36	Ymin = y;
	37	Xmax = X;
	38	Ymax = Y;
	39	Flags &= ~VoidMask;
	40	}
	41	else {
	42	if (!(Flags & XminMask) && (x < Xmin)) Xmin = x;
	43	if (!(Flags & XmaxMask) && (X > Xmax)) Xmax = X;
	44	if (!(Flags & YminMask) && (y < Ymin)) Ymin = y;
	45	if (!(Flags & YmaxMask) && (Y > Ymax)) Ymax = Y;
	46	}
	47	}
	48
	49	//=======================================================================
	50	//function : Update
	51	//purpose :
	52	//=======================================================================
	53
	54	void Bnd_Box2d::Update (const Standard_Real X, const Standard_Real Y)
	55	{
	56	if (Flags & VoidMask) {
	57	Xmin = X;
	58	Ymin = Y;
	59	Xmax = X;
	60	Ymax = Y;
	61	Flags &= ~VoidMask;
	62	}
	63	else {
	64	if (!(Flags & XminMask) && (X < Xmin)) Xmin = X;
	65	else if (!(Flags & XmaxMask) && (X > Xmax)) Xmax = X;
	66	if (!(Flags & YminMask) && (Y < Ymin)) Ymin = Y;
	67	else if (!(Flags & YmaxMask) && (Y > Ymax)) Ymax = Y;
	68	}
	69	}
	70
	71	//=======================================================================
	72	//function : Get
	73	//purpose :
	74	//=======================================================================
	75
	76	void Bnd_Box2d::Get (Standard_Real& x, Standard_Real& y,
	77	Standard_Real& Xm, Standard_Real& Ym) const
	78	{
	79	if(Flags & VoidMask)
	80	Standard_ConstructionError::Raise("Bnd_Box is void");
	81	Standard_Real pinf = 1e+100; //-- Precision::Infinite();
	82	if (Flags & XminMask) x = -pinf;
	83	else x = Xmin-Gap;
	84	if (Flags & XmaxMask) Xm = pinf;
	85	else Xm = Xmax+Gap;
	86	if (Flags & YminMask) y = -pinf;
	87	else y = Ymin-Gap;
	88	if (Flags & YmaxMask) Ym = pinf;
	89	else Ym = Ymax+Gap;
	90	}
	91
	92	//=======================================================================
	93	//function : Transformed
	94	//purpose :
95	//=======================================================================
96
97	Bnd_Box2d Bnd_Box2d::Transformed (const gp_Trsf2d& T) const
98	{
99	gp_TrsfForm F = T.Form();
100	Bnd_Box2d newb(*this);
101	if ( IsVoid() ) return newb;
102
103	if (F == gp_Identity) {}
104	else if (F == gp_Translation) {
105	Standard_Real DX,DY;
106	(T.TranslationPart()).Coord(DX,DY);
107	if (!(Flags & XminMask)) newb.Xmin += DX;
108	if (!(Flags & XmaxMask)) newb.Xmax += DX;
109	if (!(Flags & YminMask)) newb.Ymin += DY;
110	if (!(Flags & YmaxMask)) newb.Ymax += DY;
111	}
112	else {
113	gp_Pnt2d P[4];
114	Standard_Boolean Vertex[4];
115	Standard_Integer i;
116	Vertex[0] = Standard_True;
117	Vertex[1] = Standard_True;
118	Vertex[2] = Standard_True;
119	Vertex[3] = Standard_True;
120	gp_Dir2d D[6];
121	// Standard_Integer vertices = 0;
122	Standard_Integer directions = 0;
123
124	if (Flags & XminMask) {
125	D[directions].SetCoord(-1., 0.);
126	directions++;
127	Vertex[0] = Vertex[2] = Standard_False;
128	}
129	if (Flags & XmaxMask) {
130	D[directions].SetCoord( 1., 0.);
131	directions++;
132	Vertex[1] = Vertex[3] = Standard_False;
133	}
134	if (Flags & YminMask) {
135	D[directions].SetCoord( 0.,-1.);
136	directions++;
137	Vertex[0] = Vertex[1] = Standard_False;
138	}
139	if (Flags & YmaxMask) {
140	D[directions].SetCoord( 0., 1.);
141	directions++;
142	Vertex[2] = Vertex[3] = Standard_False;
143	}
144
145	newb.SetVoid();
146
147	for (i = 0; i < directions; i++) {
148	D[i].Transform(T);
149	newb.Add(D[i]);
150	}
151	P[0].SetCoord(Xmin,Ymin);
152	P[1].SetCoord(Xmax,Ymin);
153	P[2].SetCoord(Xmin,Ymax);
154	P[3].SetCoord(Xmax,Ymax);
155	if (Vertex[0]) {
156	P[0].Transform(T);
157	newb.Add(P[0]);
158	}
159	if (Vertex[1]) {
160	P[1].Transform(T);
161	newb.Add(P[1]);
162	}
163	if (Vertex[2]) {
164	P[2].Transform(T);
165	newb.Add(P[2]);
166	}
167	if (Vertex[3]) {
168	P[3].Transform(T);
169	newb.Add(P[3]);
170	}
171	newb.Gap=Gap;
172	}
173	return newb;
174	}
175
176	//=======================================================================
177	//function : Add
178	//purpose :
179	//=======================================================================
180
181	void Bnd_Box2d::Add (const Bnd_Box2d& Other)
182	{
183	if (IsWhole()) return;
184	else if (Other.IsVoid()) return;
185	else if (Other.IsWhole()) SetWhole();
186	else if (IsVoid()) (*this) = Other;
187	else
188	{
189	if ( ! IsOpenXmin() )
190	{
191	if (Other.IsOpenXmin()) OpenXmin();
192	else if (Xmin > Other.Xmin) Xmin = Other.Xmin;
193	}
194	if ( ! IsOpenXmax() )
195	{
196	if (Other.IsOpenXmax()) OpenXmax();
197	else if (Xmax < Other.Xmax) Xmax = Other.Xmax;
198	}
199	if ( ! IsOpenYmin() )
200	{
201	if (Other.IsOpenYmin()) OpenYmin();
202	else if (Ymin > Other.Ymin) Ymin = Other.Ymin;
203	}
204	if ( ! IsOpenYmax() )
205	{
206	if (Other.IsOpenYmax()) OpenYmax();
207	else if (Ymax < Other.Ymax) Ymax = Other.Ymax;
208	}
209	Gap = Max (Gap, Other.Gap);
210	}
211	}
212
213	//=======================================================================
214	//function : Add
215	//purpose :
216	//=======================================================================
217
218	void Bnd_Box2d::Add (const gp_Dir2d& D)
219	{
220	Standard_Real DX = D.X();
221	Standard_Real DY = D.Y();
44d9ae89 A	222
	223	if (DX < -RealEpsilon())
	224	OpenXmin();
	225	else if (DX > RealEpsilon())
	226	OpenXmax();
	227
	228	if (DY < -RealEpsilon())
	229	OpenYmin();
	230	else if (DY > RealEpsilon())
	231	OpenYmax();
7fd59977	232	}
	233
	234	//=======================================================================
	235	//function : IsOut
	236	//purpose :
	237	//=======================================================================
	238
	239	Standard_Boolean Bnd_Box2d::IsOut (const gp_Pnt2d& P) const
	240	{
	241	if (IsWhole()) return Standard_False;
	242	else if (IsVoid()) return Standard_True;
	243	else {
	244	Standard_Real X = P.X();
	245	Standard_Real Y = P.Y();
	246	if (!(Flags & XminMask) && (X < (Xmin-Gap))) return Standard_True;
	247	else if (!(Flags & XmaxMask) && (X > (Xmax+Gap))) return Standard_True;
	248	else if (!(Flags & YminMask) && (Y < (Ymin-Gap))) return Standard_True;
	249	else if (!(Flags & YmaxMask) && (Y > (Ymax+Gap))) return Standard_True;
	250	else return Standard_False;
	251	}
	252	}
	253
	254	//=======================================================================
	255	//function : IsOut
	256	//purpose :
	257	//=======================================================================
	258
	259	Standard_Boolean Bnd_Box2d::IsOut (const Bnd_Box2d& Other) const
	260	{
	261	if (IsWhole()) return Standard_False;
	262	else if (IsVoid()) return Standard_True;
	263	else if (Other.IsWhole()) return Standard_False;
	264	else if (Other.IsVoid()) return Standard_True;
	265	else {
7fd59977	266	Standard_Real OXmin,OXmax,OYmin,OYmax;
1145e2bc	267	Other.Get(OXmin,OYmin,OXmax,OYmax);
7fd59977	268	if (!(Flags & XminMask) && (OXmax < (Xmin-Gap))) return Standard_True;
	269	else if (!(Flags & XmaxMask) && (OXmin > (Xmax+Gap))) return Standard_True;
	270	else if (!(Flags & YminMask) && (OYmax < (Ymin-Gap))) return Standard_True;
	271	else if (!(Flags & YmaxMask) && (OYmin > (Ymax+Gap))) return Standard_True;
	272	}
	273	return Standard_False;
	274	}
	275
	276	//=======================================================================
	277	//function : Dump
	278	//purpose :
	279	//=======================================================================
	280
	281	void Bnd_Box2d::Dump () const
	282	{
	283	cout << "Box2d : ";
	284	if (IsVoid()) cout << "Void";
	285	else if (IsWhole()) cout << "Whole";
	286	else {
	287	cout << "\n Xmin : ";
	288	if (IsOpenXmin()) cout << "Infinite";
	289	else cout << Xmin;
	290	cout << "\n Xmax : ";
	291	if (IsOpenXmax()) cout << "Infinite";
	292	else cout << Xmax;
	293	cout << "\n Ymin : ";
	294	if (IsOpenYmin()) cout << "Infinite";
	295	else cout << Ymin;
	296	cout << "\n Ymax : ";
	297	if (IsOpenYmax()) cout << "Infinite";
	298	else cout << Ymax;
	299	}
	300	cout << "\n Gap : " << Gap;
	301	cout << "\n";
	302	}