eda_rect.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2004-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */

#ifndef EDA_RECT_H
#define EDA_RECT_H

#include <wx/gdicmn.h>
#include <math/box2.h>

class EDA_RECT
{
public:
 EDA_RECT() : m_init( false ) { };

 EDA_RECT( const wxPoint& aPos, const wxSize& aSize ) :
 m_pos( aPos ),
 m_size( aSize ),
 m_init( true )
 { }

 template<class T>
 EDA_RECT( const BOX2<T> aBox )
 {
 m_pos = (wxPoint) aBox.GetPosition();
 m_size.x = aBox.GetWidth();
 m_size.y = aBox.GetHeight();
 m_init = true;
 }

 virtual ~EDA_RECT() { };

 wxPoint Centre() const
 {
 return wxPoint( m_pos.x + ( m_size.x >> 1 ), m_pos.y + ( m_size.y >> 1 ) );
 }

 void Move( const wxPoint& aMoveVector );

 void Normalize();

 bool Contains( const wxPoint& aPoint ) const;

 bool Contains( int x, int y ) const { return Contains( wxPoint( x, y ) ); }

 bool Contains( const EDA_RECT& aRect ) const;

 const wxSize GetSize() const { return m_size; }

 int GetSizeMax() const { return ( m_size.x > m_size.y ) ? m_size.x : m_size.y; }

 int GetX() const { return m_pos.x; }
 int GetY() const { return m_pos.y; }

 const wxPoint GetOrigin() const { return m_pos; }
 const wxPoint GetPosition() const { return m_pos; }
 const wxPoint GetEnd() const { return wxPoint( m_pos.x + m_size.x, m_pos.y + m_size.y ); }
 const wxPoint GetCenter() const
 {
 return wxPoint( m_pos.x + ( m_size.x / 2 ), m_pos.y + ( m_size.y / 2 ) );
 }

 int GetWidth() const { return m_size.x; }
 int GetHeight() const { return m_size.y; }
 int GetRight() const { return m_pos.x + m_size.x; }
 int GetLeft() const { return m_pos.x; }
 int GetTop() const { return m_pos.y; }
 int GetBottom() const { return m_pos.y + m_size.y; } // Y axis from top to bottom

 bool IsValid() const
 {
 return m_init;
 }

 void SetOrigin( const wxPoint& pos )
 {
 m_pos = pos;
 m_init = true;
 }

 void SetOrigin( int x, int y )
 {
 m_pos.x = x;
 m_pos.y = y;
 m_init = true;
 }

 void SetSize( const wxSize& size )
 {
 m_size = size;
 m_init = true;
 }

 void SetSize( int w, int h )
 {
 m_size.x = w;
 m_size.y = h;
 m_init = true;
 }

 void Offset( int dx, int dy )
 {
 m_pos.x += dx;
 m_pos.y += dy;
 }

 void Offset( const wxPoint& offset )
 {
 m_pos += offset;
 }

 void SetX( int val )
 {
 m_pos.x = val;
 m_init = true;
 }

 void SetY( int val )
 {
 m_pos.y = val;
 m_init = true;
 }

 void SetWidth( int val )
 {
 m_size.x = val;
 m_init = true;
 }

 void SetHeight( int val )
 {
 m_size.y = val;
 m_init = true;
 }

 void SetEnd( int x, int y )
 {
 SetEnd( wxPoint( x, y ) );
 m_init = true;
 }

 void SetEnd( const wxPoint& pos )
 {
 m_size.x = pos.x - m_pos.x;
 m_size.y = pos.y - m_pos.y;
 m_init = true;
 }

 void RevertYAxis()
 {
 m_pos.y = -m_pos.y;
 m_size.y = -m_size.y;
 Normalize();
 }

 bool Intersects( const EDA_RECT& aRect ) const;

 bool Intersects( const EDA_RECT& aRect, double aRot ) const;

 bool Intersects( const wxPoint& aPoint1, const wxPoint& aPoint2 ) const;

 bool Intersects( const wxPoint& aPoint1, const wxPoint& aPoint2,
 wxPoint* aIntersection1, wxPoint* aIntersection2 ) const;

 const wxPoint ClosestPointTo( const wxPoint& aPoint ) const;

 const wxPoint FarthestPointTo( const wxPoint& aPoint ) const;

 bool IntersectsCircle( const wxPoint& aCenter, const int aRadius ) const;

 bool IntersectsCircleEdge( const wxPoint& aCenter, const int aRadius, const int aWidth ) const;

 operator wxRect() const
 {
 EDA_RECT rect( m_pos, m_size );
 rect.Normalize();
 return wxRect( rect.m_pos, rect.m_size );
 }

 operator BOX2I() const
 {
 EDA_RECT rect( m_pos, m_size );
 rect.Normalize();
 return BOX2I( rect.GetOrigin(), rect.GetSize() );
 }

 EDA_RECT& Inflate( wxCoord dx, wxCoord dy );

 EDA_RECT& Inflate( int aDelta );

 void Merge( const EDA_RECT& aRect );

 void Merge( const wxPoint& aPoint );

 double GetArea() const;

 EDA_RECT Common( const EDA_RECT& aRect ) const;

 const EDA_RECT GetBoundingBoxRotated( const wxPoint& aRotCenter, double aAngle ) const;

private:
 wxPoint m_pos; // Rectangle Origin
 wxSize m_size; // Rectangle Size
 bool m_init; // Is the rectangle initialized
};


#endif // EDA_RECT_H