KiCad PCB EDA Suite
BOX2< Vec > Class Template Reference

Class BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated class Vec. More...

#include <box2.h>

Public Types

typedef Vec::coord_type coord_type
 
typedef Vec::extended_type ecoord_type
 
typedef std::numeric_limits< coord_typecoord_limits
 

Public Member Functions

 BOX2 ()
 
 BOX2 (const Vec &aPos, const Vec &aSize)
 
void SetMaximum ()
 
Vec Centre () const
 
template<class Container >
void Compute (const Container &aPointList)
 Compute the bounding box from a given list of points. More...
 
void Move (const Vec &aMoveVector)
 Function Move moves the rectangle by the aMoveVector. More...
 
BOX2< Vec > & Normalize ()
 Function Normalize ensures that the height ant width are positive. More...
 
bool Contains (const Vec &aPoint) const
 Function Contains. More...
 
bool Contains (coord_type x, coord_type y) const
 Function Contains. More...
 
bool Contains (const BOX2< Vec > &aRect) const
 Function Contains. More...
 
const Vec & GetSize () const
 
coord_type GetX () const
 
coord_type GetY () const
 
const Vec & GetOrigin () const
 
const Vec & GetPosition () const
 
const Vec GetEnd () const
 
coord_type GetWidth () const
 
coord_type GetHeight () const
 
coord_type GetRight () const
 
coord_type GetBottom () const
 
coord_type GetLeft () const
 
coord_type GetTop () const
 
void MoveTopTo (coord_type aTop)
 
void MoveBottomTo (coord_type aBottom)
 
void MoveLeftTo (coord_type aLeft)
 
void MoveRightTo (coord_type aRight)
 
void SetOrigin (const Vec &pos)
 
void SetOrigin (coord_type x, coord_type y)
 
void SetSize (const Vec &size)
 
void SetSize (coord_type w, coord_type h)
 
void Offset (coord_type dx, coord_type dy)
 
void Offset (const Vec &offset)
 
void SetX (coord_type val)
 
void SetY (coord_type val)
 
void SetWidth (coord_type val)
 
void SetHeight (coord_type val)
 
void SetEnd (coord_type x, coord_type y)
 
void SetEnd (const Vec &pos)
 
bool Intersects (const BOX2< Vec > &aRect) const
 Function Intersects. More...
 
BOX2< Vec > Intersect (const BOX2< Vec > &aRect)
 Function Intersect Returns the intersection of this with another rectangle. More...
 
const std::string Format () const
 
BOX2< Vec > & Inflate (coord_type dx, coord_type dy)
 Function Inflate inflates the rectangle horizontally by dx and vertically by dy. More...
 
BOX2< Vec > & Inflate (int aDelta)
 Function Inflate inflates the rectangle horizontally and vertically by aDelta. More...
 
BOX2< Vec > & Merge (const BOX2< Vec > &aRect)
 Function Merge modifies the position and size of the rectangle in order to contain aRect. More...
 
BOX2< Vec > & Merge (const Vec &aPoint)
 Function Merge modifies the position and size of the rectangle in order to contain the given point. More...
 
ecoord_type GetArea () const
 Function GetArea returns the area of the rectangle. More...
 
ecoord_type Diagonal () const
 Function GetArea returns the length of the diagonal of the rectangle. More...
 
ecoord_type SquaredDistance (const Vec &aP) const
 
ecoord_type Distance (const Vec &aP) const
 
ecoord_type SquaredDistance (const BOX2< Vec > &aBox) const
 Function SquaredDistance returns the square of the minimum distance between self and box aBox. More...
 
ecoord_type Distance (const BOX2< Vec > &aBox) const
 Function Distance returns the minimum distance between self and box aBox. More...
 
bool operator== (const BOX2< Vec > &aOther) const
 
bool operator!= (const BOX2< Vec > &aOther) const
 

Private Attributes

Vec m_Pos
 
Vec m_Size
 

Detailed Description

template<class Vec>
class BOX2< Vec >

Class BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated class Vec.

Definition at line 41 of file box2.h.

Member Typedef Documentation

template<class Vec>
typedef std::numeric_limits<coord_type> BOX2< Vec >::coord_limits

Definition at line 50 of file box2.h.

template<class Vec>
typedef Vec::coord_type BOX2< Vec >::coord_type

Definition at line 48 of file box2.h.

template<class Vec>
typedef Vec::extended_type BOX2< Vec >::ecoord_type

Definition at line 49 of file box2.h.

Constructor & Destructor Documentation

template<class Vec>
BOX2< Vec >::BOX2 ( )
inline

Definition at line 52 of file box2.h.

Referenced by BOX2< VECTOR2I >::BOX2().

52 {};
template<class Vec>
BOX2< Vec >::BOX2 ( const Vec &  aPos,
const Vec &  aSize 
)
inline

Definition at line 54 of file box2.h.

54  :
55  m_Pos( aPos ),
56  m_Size( aSize )
57  {
58  Normalize();
59  }
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:127
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45

Member Function Documentation

template<class Vec>
Vec BOX2< Vec >::Centre ( ) const
inline

Definition at line 77 of file box2.h.

Referenced by COMMON_TOOLS::CenterContents(), SHAPE::Centre(), SYMBOL_PREVIEW_WIDGET::fitOnDrawArea(), KIGFX::VIEW::SetViewport(), KIGFX::WX_VIEW_CONTROLS::UpdateScrollbars(), and SCH_BASE_FRAME::Zoom_Automatique().

78  {
79  return Vec( m_Pos.x + ( m_Size.x / 2 ),
80  m_Pos.y + ( m_Size.y / 2 ) );
81  }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
template<class Container >
void BOX2< Vec >::Compute ( const Container &  aPointList)
inline

Compute the bounding box from a given list of points.

Parameters
aPointListis the list points of the object.

Definition at line 89 of file box2.h.

Referenced by SHAPE_ARC::BBox(), SHAPE_LINE_CHAIN::BBox(), and KIGFX::STROKE_FONT::computeBoundingBox().

90  {
91  Vec vmin, vmax;
92 
93  typename Container::const_iterator i;
94 
95  if( !aPointList.size() )
96  return;
97 
98  vmin = vmax = aPointList[0];
99 
100  for( i = aPointList.begin(); i != aPointList.end(); ++i )
101  {
102  Vec p( *i );
103  vmin.x = std::min( vmin.x, p.x );
104  vmin.y = std::min( vmin.y, p.y );
105  vmax.x = std::max( vmax.x, p.x );
106  vmax.y = std::max( vmax.y, p.y );
107  }
108 
109  SetOrigin( vmin );
110  SetSize( vmax - vmin );
111  }
void SetSize(const Vec &size)
Definition: box2.h:210
#define max(a, b)
Definition: auxiliary.h:86
size_t i
Definition: json11.cpp:597
void SetOrigin(const Vec &pos)
Definition: box2.h:208
#define min(a, b)
Definition: auxiliary.h:85
template<class Vec>
bool BOX2< Vec >::Contains ( const Vec &  aPoint) const
inline

Function Contains.

Parameters
aPoint= the point to test
Returns
true if aPoint is inside the boundary box. A point on a edge is seen as inside

Definition at line 149 of file box2.h.

Referenced by PNS::LINE_RESTRICTIONS::Build(), BOX2< VECTOR2I >::Contains(), POLY_GRID_PARTITION::containsPoint(), GERBVIEW_SELECTION_TOOL::selectionContains(), SELECTION_TOOL::selectionContains(), GERBVIEW_SELECTION_TOOL::selectMultiple(), SELECTION_TOOL::selectMultiple(), KIGFX::VIEW::SetCenter(), KIGFX::WX_VIEW_CONTROLS::SetCrossHairCursorPosition(), and KIGFX::WX_VIEW_CONTROLS::WarpCursor().

150  {
151  Vec rel_pos = aPoint - m_Pos;
152  Vec size = m_Size;
153 
154  if( size.x < 0 )
155  {
156  size.x = -size.x;
157  rel_pos.x += size.x;
158  }
159 
160  if( size.y < 0 )
161  {
162  size.y = -size.y;
163  rel_pos.y += size.y;
164  }
165 
166  return ( rel_pos.x >= 0 ) && ( rel_pos.y >= 0 ) && ( rel_pos.y <= size.y) && ( rel_pos.x <= size.x);
167  }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
bool BOX2< Vec >::Contains ( coord_type  x,
coord_type  y 
) const
inline

Function Contains.

Parameters
x= the x coordinate of the point to test
y= the x coordinate of the point to test
Returns
true if point is inside the boundary box. A point on a edge is seen as inside

Definition at line 175 of file box2.h.

Referenced by BOX2< VECTOR2I >::Contains().

175 { return Contains( Vec( x, y ) ); }
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:149
template<class Vec>
bool BOX2< Vec >::Contains ( const BOX2< Vec > &  aRect) const
inline

Function Contains.

Parameters
aRect= the BOX2 to test
Returns
true if aRect is Contained. A common edge is seen as contained

Definition at line 182 of file box2.h.

183  {
184  return Contains( aRect.GetOrigin() ) && Contains( aRect.GetEnd() );
185  }
const Vec & GetOrigin() const
Definition: box2.h:191
const Vec GetEnd() const
Definition: box2.h:193
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:149
template<class Vec>
ecoord_type BOX2< Vec >::Diagonal ( ) const
inline

Function GetArea returns the length of the diagonal of the rectangle.

Returns
The area of the diagonal.

Definition at line 435 of file box2.h.

436  {
437  return m_Size.EuclideanNorm();
438  }
Vec m_Size
Definition: box2.h:45
template<class Vec>
ecoord_type BOX2< Vec >::Distance ( const Vec &  aP) const
inline

Definition at line 449 of file box2.h.

450  {
451  return sqrt( SquaredDistance( aP ) );
452  }
ecoord_type SquaredDistance(const Vec &aP) const
Definition: box2.h:440
template<class Vec>
ecoord_type BOX2< Vec >::Distance ( const BOX2< Vec > &  aBox) const
inline

Function Distance returns the minimum distance between self and box aBox.

Parameters
aBoxthe other box
Returns
The distance

Definition at line 495 of file box2.h.

496  {
497  return sqrt( SquaredDistance( aBox ) );
498  }
ecoord_type SquaredDistance(const Vec &aP) const
Definition: box2.h:440
template<class Vec>
const std::string BOX2< Vec >::Format ( ) const
inline

Definition at line 286 of file box2.h.

287  {
288  std::stringstream ss;
289 
290  ss << "( box corner " << m_Pos.Format() << " w " << m_Size.x << " h " << m_Size.y << " )";
291 
292  return ss.str();
293  }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
ecoord_type BOX2< Vec >::GetArea ( ) const
inline

Function GetArea returns the area of the rectangle.

Returns
The area of the rectangle.

Definition at line 425 of file box2.h.

426  {
427  return (ecoord_type) GetWidth() * (ecoord_type) GetHeight();
428  }
coord_type GetWidth() const
Definition: box2.h:195
Vec::extended_type ecoord_type
Definition: box2.h:49
coord_type GetHeight() const
Definition: box2.h:196
template<class Vec>
const Vec BOX2< Vec >::GetEnd ( ) const
inline
template<class Vec>
coord_type BOX2< Vec >::GetLeft ( ) const
inline

Definition at line 201 of file box2.h.

Referenced by Convert_path_polygon_to_polygon_blocks_and_dummy_blocks(), KIGFX::VIEW::SetCenter(), and KIGFX::WX_VIEW_CONTROLS::UpdateScrollbars().

201 { return GetX(); }
coord_type GetX() const
Definition: box2.h:188
template<class Vec>
coord_type BOX2< Vec >::GetTop ( ) const
inline
template<class Vec>
BOX2<Vec>& BOX2< Vec >::Inflate ( coord_type  dx,
coord_type  dy 
)
inline

Function Inflate inflates the rectangle horizontally by dx and vertically by dy.

If dx and/or dy is negative the rectangle is deflated.

Definition at line 300 of file box2.h.

Referenced by SHAPE_SEGMENT::BBox(), SHAPE_ARC::BBox(), SHAPE_LINE_CHAIN::BBox(), SHAPE_POLY_SET::BBox(), ZONE_FILLER::buildUnconnectedThermalStubsPolygonList(), PNS::LINE::ChangedArea(), PCB_EDIT_FRAME::ExecuteRemoteCommand(), BOX2< VECTOR2I >::Inflate(), SHAPE_INDEX< T >::Query(), DIALOG_PAD_PROPERTIES::redraw(), GERBVIEW_SELECTION_TOOL::selectionContains(), SELECTION_TOOL::selectionContains(), ROUTER_PREVIEW_ITEM::ViewBBox(), and TRACK::ViewBBox().

301  {
302  if( m_Size.x >= 0 )
303  {
304  if( m_Size.x < -2 * dx )
305  {
306  // Don't allow deflate to eat more width than we have,
307  m_Pos.x += m_Size.x / 2;
308  m_Size.x = 0;
309  }
310  else
311  {
312  // The inflate is valid.
313  m_Pos.x -= dx;
314  m_Size.x += 2 * dx;
315  }
316  }
317  else // size.x < 0:
318  {
319  if( m_Size.x > -2 * dx )
320  {
321  // Don't allow deflate to eat more width than we have,
322  m_Pos.x -= m_Size.x / 2;
323  m_Size.x = 0;
324  }
325  else
326  {
327  // The inflate is valid.
328  m_Pos.x += dx;
329  m_Size.x -= 2 * dx; // m_Size.x <0: inflate when dx > 0
330  }
331  }
332 
333  if( m_Size.y >= 0 )
334  {
335  if( m_Size.y < -2 * dy )
336  {
337  // Don't allow deflate to eat more height than we have,
338  m_Pos.y += m_Size.y / 2;
339  m_Size.y = 0;
340  }
341  else
342  {
343  // The inflate is valid.
344  m_Pos.y -= dy;
345  m_Size.y += 2 * dy;
346  }
347  }
348  else // size.y < 0:
349  {
350  if( m_Size.y > 2 * dy )
351  {
352  // Don't allow deflate to eat more height than we have,
353  m_Pos.y -= m_Size.y / 2;
354  m_Size.y = 0;
355  }
356  else
357  {
358  // The inflate is valid.
359  m_Pos.y += dy;
360  m_Size.y -= 2 * dy; // m_Size.y <0: inflate when dy > 0
361  }
362  }
363 
364  return *this;
365  }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
BOX2<Vec>& BOX2< Vec >::Inflate ( int  aDelta)
inline

Function Inflate inflates the rectangle horizontally and vertically by aDelta.

If aDelta is negative the rectangle is deflated.

Definition at line 372 of file box2.h.

373  {
374  Inflate( aDelta, aDelta );
375  return *this;
376  }
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:300
template<class Vec>
BOX2<Vec> BOX2< Vec >::Intersect ( const BOX2< Vec > &  aRect)
inline

Function Intersect Returns the intersection of this with another rectangle.

Definition at line 266 of file box2.h.

Referenced by KIGFX::VIEW::SetCenter().

267  {
268  BOX2<Vec> me( *this );
269  BOX2<Vec> rect( aRect );
270  me.Normalize(); // ensure size is >= 0
271  rect.Normalize(); // ensure size is >= 0
272 
273  Vec topLeft, bottomRight;
274 
275  topLeft.x = std::max( me.m_Pos.x, rect.m_Pos.x );
276  bottomRight.x = std::min( me.m_Pos.x + me.m_Size.x, rect.m_Pos.x + rect.m_Size.x );
277  topLeft.y = std::max( me.m_Pos.y, rect.m_Pos.y );
278  bottomRight.y = std::min( me.m_Pos.y + me.m_Size.y, rect.m_Pos.y + rect.m_Size.y );
279 
280  if ( topLeft.x < bottomRight.x && topLeft.y < bottomRight.y )
281  return BOX2<Vec>( topLeft, bottomRight - topLeft );
282  else
283  return BOX2<Vec>( Vec( 0, 0 ), Vec( 0, 0 ) );
284  }
Class BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated class Vec.
Definition: box2.h:41
#define max(a, b)
Definition: auxiliary.h:86
#define min(a, b)
Definition: auxiliary.h:85
template<class Vec>
bool BOX2< Vec >::Intersects ( const BOX2< Vec > &  aRect) const
inline

Function Intersects.

Returns
bool - true if the argument rectangle intersects this rectangle. (i.e. if the 2 rectangles have at least a common point)

Definition at line 234 of file box2.h.

Referenced by ZONE_FILLER::buildUnconnectedThermalStubsPolygonList(), BOARD::CombineAllAreasInNet(), SHAPE_LINE_CHAIN::Intersect(), and BOARD::TestAreaIntersection().

235  {
236  // this logic taken from wxWidgets' geometry.cpp file:
237  bool rc;
238 
239  BOX2<Vec> me( *this );
240  BOX2<Vec> rect( aRect );
241  me.Normalize(); // ensure size is >= 0
242  rect.Normalize(); // ensure size is >= 0
243 
244  // calculate the left common area coordinate:
245  int left = std::max( me.m_Pos.x, rect.m_Pos.x );
246  // calculate the right common area coordinate:
247  int right = std::min( me.m_Pos.x + me.m_Size.x, rect.m_Pos.x + rect.m_Size.x );
248  // calculate the upper common area coordinate:
249  int top = std::max( me.m_Pos.y, aRect.m_Pos.y );
250  // calculate the lower common area coordinate:
251  int bottom = std::min( me.m_Pos.y + me.m_Size.y, rect.m_Pos.y + rect.m_Size.y );
252 
253  // if a common area exists, it must have a positive (null accepted) size
254  if( left <= right && top <= bottom )
255  rc = true;
256  else
257  rc = false;
258 
259  return rc;
260  }
Class BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated class Vec.
Definition: box2.h:41
Vec m_Pos
Definition: box2.h:44
#define max(a, b)
Definition: auxiliary.h:86
#define min(a, b)
Definition: auxiliary.h:85
template<class Vec>
BOX2<Vec>& BOX2< Vec >::Merge ( const BOX2< Vec > &  aRect)
inline

Function Merge modifies the position and size of the rectangle in order to contain aRect.

It is mainly used to calculate bounding boxes.

Parameters
aRectThe rectangle to merge with this rectangle.

Definition at line 384 of file box2.h.

Referenced by SHAPE_LINE_CHAIN::Append(), SHAPE_POLY_SET::BBox(), PNS::VIA::ChangedArea(), PCB_EDIT_FRAME::ExecuteRemoteCommand(), PNS::extendBox(), KIGFX::VIEW::extentsVisitor::operator()(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), KIGFX::VIEW_GROUP::ViewBBox(), DIMENSION::ViewBBox(), and EDIT_POINTS::ViewBBox().

385  {
386  Normalize(); // ensure width and height >= 0
387  BOX2<Vec> rect = aRect;
388  rect.Normalize(); // ensure width and height >= 0
389  Vec end = GetEnd();
390  Vec rect_end = rect.GetEnd();
391 
392  // Change origin and size in order to contain the given rect
393  m_Pos.x = std::min( m_Pos.x, rect.m_Pos.x );
394  m_Pos.y = std::min( m_Pos.y, rect.m_Pos.y );
395  end.x = std::max( end.x, rect_end.x );
396  end.y = std::max( end.y, rect_end.y );
397  SetEnd( end );
398  return *this;
399  }
const Vec GetEnd() const
Definition: box2.h:193
Class BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated class Vec.
Definition: box2.h:41
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:127
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:223
Vec m_Pos
Definition: box2.h:44
#define max(a, b)
Definition: auxiliary.h:86
#define min(a, b)
Definition: auxiliary.h:85
template<class Vec>
BOX2<Vec>& BOX2< Vec >::Merge ( const Vec &  aPoint)
inline

Function Merge modifies the position and size of the rectangle in order to contain the given point.

Parameters
aPointThe point to merge with the rectangle.

Definition at line 406 of file box2.h.

407  {
408  Normalize(); // ensure width and height >= 0
409 
410  Vec end = GetEnd();
411  // Change origin and size in order to contain the given rect
412  m_Pos.x = std::min( m_Pos.x, aPoint.x );
413  m_Pos.y = std::min( m_Pos.y, aPoint.y );
414  end.x = std::max( end.x, aPoint.x );
415  end.y = std::max( end.y, aPoint.y );
416  SetEnd( end );
417  return *this;
418  }
const Vec GetEnd() const
Definition: box2.h:193
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:127
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:223
Vec m_Pos
Definition: box2.h:44
#define max(a, b)
Definition: auxiliary.h:86
#define min(a, b)
Definition: auxiliary.h:85
template<class Vec>
void BOX2< Vec >::Move ( const Vec &  aMoveVector)
inline

Function Move moves the rectangle by the aMoveVector.

Parameters
aMoveVectorA point that is the value to move this rectangle

Definition at line 118 of file box2.h.

Referenced by DIALOG_PAD_PROPERTIES::redraw().

119  {
120  m_Pos += aMoveVector;
121  }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
void BOX2< Vec >::MoveBottomTo ( coord_type  aBottom)
inline

Definition at line 204 of file box2.h.

204 { m_Size.y = aBottom - m_Pos.y; }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::MoveLeftTo ( coord_type  aLeft)
inline

Definition at line 205 of file box2.h.

205 { m_Pos.x = aLeft; }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
void BOX2< Vec >::MoveRightTo ( coord_type  aRight)
inline

Definition at line 206 of file box2.h.

206 { m_Size.x = aRight - m_Pos.x; }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::MoveTopTo ( coord_type  aTop)
inline

Definition at line 203 of file box2.h.

203 { m_Pos.y = aTop; }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
BOX2<Vec>& BOX2< Vec >::Normalize ( )
inline

Function Normalize ensures that the height ant width are positive.

Definition at line 127 of file box2.h.

Referenced by BOX2< VECTOR2I >::BOX2(), PNS::ConvexHull(), KIGFX::VIEW::GetViewport(), BOX2< VECTOR2I >::Intersect(), BOX2< VECTOR2I >::Intersects(), BOX2< VECTOR2I >::Merge(), SVG_PLOTTER::Rect(), KIGFX::VIEW::Redraw(), KIGFX::PREVIEW::ARC_ASSISTANT::ViewBBox(), KIGFX::PREVIEW::RULER_ITEM::ViewBBox(), and KIGFX::PREVIEW::SELECTION_AREA::ViewBBox().

128  {
129  if( m_Size.y < 0 )
130  {
131  m_Size.y = -m_Size.y;
132  m_Pos.y -= m_Size.y;
133  }
134 
135  if( m_Size.x < 0 )
136  {
137  m_Size.x = -m_Size.x;
138  m_Pos.x -= m_Size.x;
139  }
140 
141  return *this;
142  }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::Offset ( coord_type  dx,
coord_type  dy 
)
inline

Definition at line 212 of file box2.h.

212 { m_Pos.x += dx; m_Pos.y += dy; }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
void BOX2< Vec >::Offset ( const Vec &  offset)
inline

Definition at line 213 of file box2.h.

214  {
215  m_Pos.x += offset.x; m_Pos.y +=
216  offset.y;
217  }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
bool BOX2< Vec >::operator!= ( const BOX2< Vec > &  aOther) const
inline

Definition at line 509 of file box2.h.

510  {
511  auto t1 ( *this );
512  auto t2 ( aOther );
513  t1.Normalize();
514  t2.Normalize();
515  return ( t1.m_Pos != t2.m_Pos || t1.m_Size != t2.m_Size );
516  }
template<class Vec>
bool BOX2< Vec >::operator== ( const BOX2< Vec > &  aOther) const
inline

Definition at line 500 of file box2.h.

501  {
502  auto t1 ( *this );
503  auto t2 ( aOther );
504  t1.Normalize();
505  t2.Normalize();
506  return ( t1.m_Pos == t2.m_Pos && t1.m_Size == t2.m_Size );
507  }
template<class Vec>
void BOX2< Vec >::SetEnd ( const Vec &  pos)
inline

Definition at line 224 of file box2.h.

225  {
226  m_Size.x = pos.x - m_Pos.x; m_Size.y = pos.y - m_Pos.y;
227  }
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::SetHeight ( coord_type  val)
inline

Definition at line 222 of file box2.h.

222 { m_Size.y = val; }
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::SetOrigin ( coord_type  x,
coord_type  y 
)
inline

Definition at line 209 of file box2.h.

209 { m_Pos.x = x; m_Pos.y = y; }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
void BOX2< Vec >::SetSize ( const Vec &  size)
inline

Definition at line 210 of file box2.h.

Referenced by BOX2< VECTOR2I >::Compute().

210 { m_Size = size; }
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::SetSize ( coord_type  w,
coord_type  h 
)
inline

Definition at line 211 of file box2.h.

211 { m_Size.x = w; m_Size.y = h; }
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::SetWidth ( coord_type  val)
inline

Definition at line 221 of file box2.h.

221 { m_Size.x = val; }
Vec m_Size
Definition: box2.h:45
template<class Vec>
void BOX2< Vec >::SetX ( coord_type  val)
inline

Definition at line 219 of file box2.h.

219 { m_Pos.x = val; }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
void BOX2< Vec >::SetY ( coord_type  val)
inline

Definition at line 220 of file box2.h.

220 { m_Pos.y = val; }
Vec m_Pos
Definition: box2.h:44
template<class Vec>
ecoord_type BOX2< Vec >::SquaredDistance ( const Vec &  aP) const
inline

Definition at line 440 of file box2.h.

Referenced by SHAPE_LINE_CHAIN::Collide(), BOX2< VECTOR2I >::Distance(), and SHAPE_INDEX_LIST< PNS::ITEM * >::Query().

441  {
442  ecoord_type x2 = m_Pos.x + m_Size.x;
443  ecoord_type y2 = m_Pos.y + m_Size.y;
444  ecoord_type xdiff = std::max( aP.x < m_Pos.x ? m_Pos.x - aP.x : m_Pos.x - x2, (ecoord_type) 0 );
445  ecoord_type ydiff = std::max( aP.y < m_Pos.y ? m_Pos.y - aP.y : m_Pos.y - y2, (ecoord_type) 0 );
446  return xdiff * xdiff + ydiff * ydiff;
447  }
Vec::extended_type ecoord_type
Definition: box2.h:49
Vec m_Pos
Definition: box2.h:44
#define max(a, b)
Definition: auxiliary.h:86
Vec m_Size
Definition: box2.h:45
template<class Vec>
ecoord_type BOX2< Vec >::SquaredDistance ( const BOX2< Vec > &  aBox) const
inline

Function SquaredDistance returns the square of the minimum distance between self and box aBox.

Parameters
aBoxthe other box
Returns
The distance, squared

Definition at line 460 of file box2.h.

461  {
462  ecoord_type s = 0;
463 
464  if( aBox.m_Pos.x + aBox.m_Size.x < m_Pos.x )
465  {
466  ecoord_type d = aBox.m_Pos.x + aBox.m_Size.x - m_Pos.x;
467  s += d * d;
468  }
469  else if( aBox.m_Pos.x > m_Pos.x + m_Size.x )
470  {
471  ecoord_type d = aBox.m_Pos.x - m_Size.x - m_Pos.x;
472  s += d * d;
473  }
474 
475  if( aBox.m_Pos.y + aBox.m_Size.y < m_Pos.y )
476  {
477  ecoord_type d = aBox.m_Pos.y + aBox.m_Size.y - m_Pos.y;
478  s += d * d;
479  }
480  else if( aBox.m_Pos.y > m_Pos.y + m_Size.y )
481  {
482  ecoord_type d = aBox.m_Pos.y - m_Size.y - m_Pos.y;
483  s += d * d;
484  }
485 
486  return s;
487  }
Vec::extended_type ecoord_type
Definition: box2.h:49
Vec m_Pos
Definition: box2.h:44
Vec m_Size
Definition: box2.h:45

Member Data Documentation


The documentation for this class was generated from the following file: