KiCad PCB EDA Suite
BOX2< Vec > Class Template Reference

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=Vec(0, 0))
 
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 >

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 43 of file box2.h.

Member Typedef Documentation

◆ coord_limits

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

Definition at line 52 of file box2.h.

◆ coord_type

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

Definition at line 50 of file box2.h.

◆ ecoord_type

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

Definition at line 51 of file box2.h.

Constructor & Destructor Documentation

◆ BOX2() [1/2]

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

Definition at line 54 of file box2.h.

54 {};

◆ BOX2() [2/2]

template<class Vec>
BOX2< Vec >::BOX2 ( const Vec &  aPos,
const Vec &  aSize = Vec(0, 0) 
)
inline

Definition at line 56 of file box2.h.

56  :
57  m_Pos( aPos ),
58  m_Size( aSize )
59  {
60  Normalize();
61  }
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:129
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

Member Function Documentation

◆ Centre()

◆ Compute()

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 91 of file box2.h.

92  {
93  Vec vmin, vmax;
94 
95  typename Container::const_iterator i;
96 
97  if( !aPointList.size() )
98  return;
99 
100  vmin = vmax = aPointList[0];
101 
102  for( i = aPointList.begin(); i != aPointList.end(); ++i )
103  {
104  Vec p( *i );
105  vmin.x = std::min( vmin.x, p.x );
106  vmin.y = std::min( vmin.y, p.y );
107  vmax.x = std::max( vmax.x, p.x );
108  vmax.y = std::max( vmax.y, p.y );
109  }
110 
111  SetOrigin( vmin );
112  SetSize( vmax - vmin );
113  }
void SetSize(const Vec &size)
Definition: box2.h:212
void SetOrigin(const Vec &pos)
Definition: box2.h:210

Referenced by SHAPE_LINE_CHAIN::BBox(), SHAPE_LINE_CHAIN::GenerateBBoxCache(), and SHAPE_ARC::update_bbox().

◆ Contains() [1/3]

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 151 of file box2.h.

152  {
153  Vec rel_pos = aPoint - m_Pos;
154  Vec size = m_Size;
155 
156  if( size.x < 0 )
157  {
158  size.x = -size.x;
159  rel_pos.x += size.x;
160  }
161 
162  if( size.y < 0 )
163  {
164  size.y = -size.y;
165  rel_pos.y += size.y;
166  }
167 
168  return ( rel_pos.x >= 0 ) && ( rel_pos.y >= 0 ) && ( rel_pos.y <= size.y) && ( rel_pos.x <= size.x);
169  }
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

Referenced by PNS::AREA_CONSTRAINT::Check(), CN_VISITOR::checkZoneZoneConnection(), BOX2< VECTOR2I >::Contains(), POLY_GRID_PARTITION::containsPoint(), EDA_DRAW_FRAME::FocusOnLocation(), PNS::NODE::QueryJoints(), PL_SELECTION_TOOL::selectionContains(), EE_SELECTION_TOOL::selectionContains(), SELECTION_TOOL::selectionContains(), KIGFX::VIEW::SetCenter(), KIGFX::WX_VIEW_CONTROLS::SetCrossHairCursorPosition(), and KIGFX::WX_VIEW_CONTROLS::WarpCursor().

◆ Contains() [2/3]

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 177 of file box2.h.

177 { return Contains( Vec( x, y ) ); }
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:151

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

◆ Contains() [3/3]

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 184 of file box2.h.

185  {
186  return Contains( aRect.GetOrigin() ) && Contains( aRect.GetEnd() );
187  }
const Vec GetEnd() const
Definition: box2.h:195
bool Contains(const Vec &aPoint) const
Function Contains.
Definition: box2.h:151
const Vec & GetOrigin() const
Definition: box2.h:193

◆ Diagonal()

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 437 of file box2.h.

438  {
439  return m_Size.EuclideanNorm();
440  }
Vec m_Size
Definition: box2.h:47

◆ Distance() [1/2]

template<class Vec>
ecoord_type BOX2< Vec >::Distance ( const Vec &  aP) const
inline

Definition at line 451 of file box2.h.

452  {
453  return sqrt( SquaredDistance( aP ) );
454  }
ecoord_type SquaredDistance(const Vec &aP) const
Definition: box2.h:442

Referenced by SHAPE_INDEX_LIST< T, >::query_iterator::next().

◆ Distance() [2/2]

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 497 of file box2.h.

498  {
499  return sqrt( SquaredDistance( aBox ) );
500  }
ecoord_type SquaredDistance(const Vec &aP) const
Definition: box2.h:442

◆ Format()

template<class Vec>
const std::string BOX2< Vec >::Format ( ) const
inline

Definition at line 288 of file box2.h.

289  {
290  std::stringstream ss;
291 
292  ss << "( box corner " << m_Pos.Format() << " w " << m_Size.x << " h " << m_Size.y << " )";
293 
294  return ss.str();
295  }
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

◆ GetArea()

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 427 of file box2.h.

428  {
429  return (ecoord_type) GetWidth() * (ecoord_type) GetHeight();
430  }
Vec::extended_type ecoord_type
Definition: box2.h:51
coord_type GetWidth() const
Definition: box2.h:197
coord_type GetHeight() const
Definition: box2.h:198

◆ GetBottom()

◆ GetEnd()

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

◆ GetHeight()

◆ GetLeft()

template<class Vec>
coord_type BOX2< Vec >::GetLeft ( ) const
inline

◆ GetOrigin()

◆ GetPosition()

◆ GetRight()

◆ GetSize()

◆ GetTop()

◆ GetWidth()

◆ GetX()

◆ GetY()

◆ Inflate() [1/2]

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 302 of file box2.h.

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

Referenced by SHAPE_SEGMENT::BBox(), SHAPE_ARC::BBox(), SHAPE_POLY_SET::TRIANGULATED_POLYGON::TRI::BBox(), SHAPE_LINE_CHAIN::BBox(), SHAPE_POLY_SET::BBox(), ZONE_FILLER::buildThermalSpokes(), PNS::LINE::ChangedArea(), PCB_EDIT_FRAME::ExecuteRemoteCommand(), EDA_DRAW_FRAME::FocusOnLocation(), SHAPE_LINE_CHAIN::GenerateBBoxCache(), DIMENSION::GetBoundingBox(), FOOTPRINT_EDIT_FRAME::GetDocumentExtents(), BOX2< VECTOR2I >::Inflate(), SHAPE_INDEX< T >::Query(), DIALOG_PAD_PROPERTIES::redraw(), PL_SELECTION_TOOL::selectionContains(), EE_SELECTION_TOOL::selectionContains(), SELECTION_TOOL::selectionContains(), ROUTER_PREVIEW_ITEM::ViewBBox(), and TRACK::ViewBBox().

◆ Inflate() [2/2]

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 374 of file box2.h.

375  {
376  Inflate( aDelta, aDelta );
377  return *this;
378  }
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Function Inflate inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:302

◆ Intersect()

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 268 of file box2.h.

269  {
270  BOX2<Vec> me( *this );
271  BOX2<Vec> rect( aRect );
272  me.Normalize(); // ensure size is >= 0
273  rect.Normalize(); // ensure size is >= 0
274 
275  Vec topLeft, bottomRight;
276 
277  topLeft.x = std::max( me.m_Pos.x, rect.m_Pos.x );
278  bottomRight.x = std::min( me.m_Pos.x + me.m_Size.x, rect.m_Pos.x + rect.m_Size.x );
279  topLeft.y = std::max( me.m_Pos.y, rect.m_Pos.y );
280  bottomRight.y = std::min( me.m_Pos.y + me.m_Size.y, rect.m_Pos.y + rect.m_Size.y );
281 
282  if ( topLeft.x < bottomRight.x && topLeft.y < bottomRight.y )
283  return BOX2<Vec>( topLeft, bottomRight - topLeft );
284  else
285  return BOX2<Vec>( Vec( 0, 0 ), Vec( 0, 0 ) );
286  }
BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated c...
Definition: box2.h:43

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

◆ Intersects()

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 236 of file box2.h.

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

Referenced by ZONE_FILLER::buildThermalSpokes(), CN_VISITOR::checkZoneItemConnection(), BOARD::CombineAllAreasInNet(), SHAPE_LINE_CHAIN::Intersect(), BOARD::TestAreaIntersection(), and DRC_TEST_PROVIDER_COURTYARD_CLEARANCE::testOverlappingComponentCourtyards().

◆ Merge() [1/2]

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 386 of file box2.h.

387  {
388  Normalize(); // ensure width and height >= 0
389  BOX2<Vec> rect = aRect;
390  rect.Normalize(); // ensure width and height >= 0
391  Vec end = GetEnd();
392  Vec rect_end = rect.GetEnd();
393 
394  // Change origin and size in order to contain the given rect
395  m_Pos.x = std::min( m_Pos.x, rect.m_Pos.x );
396  m_Pos.y = std::min( m_Pos.y, rect.m_Pos.y );
397  end.x = std::max( end.x, rect_end.x );
398  end.y = std::max( end.y, rect_end.y );
399  SetEnd( end );
400  return *this;
401  }
const Vec GetEnd() const
Definition: box2.h:195
BOX2 handles a 2-D bounding box, built on top of an origin point and size vector, both of templated c...
Definition: box2.h:43
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:129
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:225
Vec m_Pos
Definition: box2.h:46

Referenced by SHAPE_LINE_CHAIN::Append(), SHAPE_COMPOUND::BBox(), SHAPE_POLY_SET::TRIANGULATED_POLYGON::TRI::BBox(), SHAPE_POLY_SET::BBox(), SHAPE_POLY_SET::BBoxFromCaches(), PNS::ARC::ChangedArea(), PNS::VIA::ChangedArea(), PCB_EDIT_FRAME::ExecuteRemoteCommand(), PNS::extendBox(), DIALOG_BOARD_STATISTICS::getDataFromPCB(), FOOTPRINT_PREVIEW_PANEL::renderFootprint(), KIGFX::VIEW_GROUP::ViewBBox(), DIMENSION::ViewBBox(), and EDIT_POINTS::ViewBBox().

◆ Merge() [2/2]

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 408 of file box2.h.

409  {
410  Normalize(); // ensure width and height >= 0
411 
412  Vec end = GetEnd();
413  // Change origin and size in order to contain the given rect
414  m_Pos.x = std::min( m_Pos.x, aPoint.x );
415  m_Pos.y = std::min( m_Pos.y, aPoint.y );
416  end.x = std::max( end.x, aPoint.x );
417  end.y = std::max( end.y, aPoint.y );
418  SetEnd( end );
419  return *this;
420  }
const Vec GetEnd() const
Definition: box2.h:195
BOX2< Vec > & Normalize()
Function Normalize ensures that the height ant width are positive.
Definition: box2.h:129
void SetEnd(coord_type x, coord_type y)
Definition: box2.h:225
Vec m_Pos
Definition: box2.h:46

◆ Move()

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 120 of file box2.h.

121  {
122  m_Pos += aMoveVector;
123  }
Vec m_Pos
Definition: box2.h:46

Referenced by DIALOG_PAD_PROPERTIES::redraw().

◆ MoveBottomTo()

template<class Vec>
void BOX2< Vec >::MoveBottomTo ( coord_type  aBottom)
inline

Definition at line 206 of file box2.h.

206 { m_Size.y = aBottom - m_Pos.y; }
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

◆ MoveLeftTo()

template<class Vec>
void BOX2< Vec >::MoveLeftTo ( coord_type  aLeft)
inline

Definition at line 207 of file box2.h.

207 { m_Pos.x = aLeft; }
Vec m_Pos
Definition: box2.h:46

◆ MoveRightTo()

template<class Vec>
void BOX2< Vec >::MoveRightTo ( coord_type  aRight)
inline

Definition at line 208 of file box2.h.

208 { m_Size.x = aRight - m_Pos.x; }
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

◆ MoveTopTo()

template<class Vec>
void BOX2< Vec >::MoveTopTo ( coord_type  aTop)
inline

Definition at line 205 of file box2.h.

205 { m_Pos.y = aTop; }
Vec m_Pos
Definition: box2.h:46

◆ Normalize()

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

Function Normalize ensures that the height ant width are positive.

Definition at line 129 of file box2.h.

130  {
131  if( m_Size.y < 0 )
132  {
133  m_Size.y = -m_Size.y;
134  m_Pos.y -= m_Size.y;
135  }
136 
137  if( m_Size.x < 0 )
138  {
139  m_Size.x = -m_Size.x;
140  m_Pos.x -= m_Size.x;
141  }
142 
143  return *this;
144  }
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

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(), KIGFX::PREVIEW::SELECTION_AREA::ViewBBox(), and KIGFX::PREVIEW::TWO_POINT_ASSISTANT::ViewBBox().

◆ Offset() [1/2]

template<class Vec>
void BOX2< Vec >::Offset ( coord_type  dx,
coord_type  dy 
)
inline

Definition at line 214 of file box2.h.

214 { m_Pos.x += dx; m_Pos.y += dy; }
Vec m_Pos
Definition: box2.h:46

◆ Offset() [2/2]

template<class Vec>
void BOX2< Vec >::Offset ( const Vec &  offset)
inline

Definition at line 215 of file box2.h.

216  {
217  m_Pos.x += offset.x; m_Pos.y +=
218  offset.y;
219  }
Vec m_Pos
Definition: box2.h:46

◆ operator!=()

template<class Vec>
bool BOX2< Vec >::operator!= ( const BOX2< Vec > &  aOther) const
inline

Definition at line 511 of file box2.h.

512  {
513  auto t1 ( *this );
514  auto t2 ( aOther );
515  t1.Normalize();
516  t2.Normalize();
517  return ( t1.m_Pos != t2.m_Pos || t1.m_Size != t2.m_Size );
518  }

◆ operator==()

template<class Vec>
bool BOX2< Vec >::operator== ( const BOX2< Vec > &  aOther) const
inline

Definition at line 502 of file box2.h.

503  {
504  auto t1 ( *this );
505  auto t2 ( aOther );
506  t1.Normalize();
507  t2.Normalize();
508  return ( t1.m_Pos == t2.m_Pos && t1.m_Size == t2.m_Size );
509  }

◆ SetEnd() [1/2]

◆ SetEnd() [2/2]

template<class Vec>
void BOX2< Vec >::SetEnd ( const Vec &  pos)
inline

Definition at line 226 of file box2.h.

227  {
228  m_Size.x = pos.x - m_Pos.x; m_Size.y = pos.y - m_Pos.y;
229  }
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

◆ SetHeight()

template<class Vec>
void BOX2< Vec >::SetHeight ( coord_type  val)
inline

Definition at line 224 of file box2.h.

224 { m_Size.y = val; }
Vec m_Size
Definition: box2.h:47

◆ SetMaximum()

◆ SetOrigin() [1/2]

◆ SetOrigin() [2/2]

template<class Vec>
void BOX2< Vec >::SetOrigin ( coord_type  x,
coord_type  y 
)
inline

Definition at line 211 of file box2.h.

211 { m_Pos.x = x; m_Pos.y = y; }
Vec m_Pos
Definition: box2.h:46

◆ SetSize() [1/2]

template<class Vec>
void BOX2< Vec >::SetSize ( const Vec &  size)
inline

◆ SetSize() [2/2]

template<class Vec>
void BOX2< Vec >::SetSize ( coord_type  w,
coord_type  h 
)
inline

Definition at line 213 of file box2.h.

213 { m_Size.x = w; m_Size.y = h; }
Vec m_Size
Definition: box2.h:47

◆ SetWidth()

template<class Vec>
void BOX2< Vec >::SetWidth ( coord_type  val)
inline

Definition at line 223 of file box2.h.

223 { m_Size.x = val; }
Vec m_Size
Definition: box2.h:47

◆ SetX()

template<class Vec>
void BOX2< Vec >::SetX ( coord_type  val)
inline

Definition at line 221 of file box2.h.

221 { m_Pos.x = val; }
Vec m_Pos
Definition: box2.h:46

◆ SetY()

template<class Vec>
void BOX2< Vec >::SetY ( coord_type  val)
inline

Definition at line 222 of file box2.h.

222 { m_Pos.y = val; }
Vec m_Pos
Definition: box2.h:46

◆ SquaredDistance() [1/2]

template<class Vec>
ecoord_type BOX2< Vec >::SquaredDistance ( const Vec &  aP) const
inline

Definition at line 442 of file box2.h.

443  {
444  ecoord_type x2 = m_Pos.x + m_Size.x;
445  ecoord_type y2 = m_Pos.y + m_Size.y;
446  ecoord_type xdiff = std::max( aP.x < m_Pos.x ? m_Pos.x - aP.x : m_Pos.x - x2, (ecoord_type) 0 );
447  ecoord_type ydiff = std::max( aP.y < m_Pos.y ? m_Pos.y - aP.y : m_Pos.y - y2, (ecoord_type) 0 );
448  return xdiff * xdiff + ydiff * ydiff;
449  }
Vec::extended_type ecoord_type
Definition: box2.h:51
Vec m_Pos
Definition: box2.h:46
Vec m_Size
Definition: box2.h:47

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

◆ SquaredDistance() [2/2]

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 462 of file box2.h.

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

Member Data Documentation

◆ m_Pos

◆ m_Size


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