Browse Source
* Add DRECT, DPOINT, and DSIZE (double rect, point, and size) using Torsten's vector2d.h
* Add DRECT, DPOINT, and DSIZE (double rect, point, and size) using Torsten's vector2d.h
as a starting point * Make double Distance() take double arguments and remove internal range checking. * Start on EDA_DRAW_FRAME::AdjustScrollBars() and use "double" for most all calculations in anticipation of setting INT_MAX INT_MIN limits eventually.pull/1/head
Dick Hollenbeck
14 years ago
11 changed files with 695 additions and 298 deletions
-
31common/base_screen.cpp
-
391common/drawframe.cpp
-
55common/drawpanel.cpp
-
32common/zoom.cpp
-
16include/class_base_screen.h
-
399include/vector2d.h
-
5include/wxstruct.h
-
9pcbnew/basepcbframe.cpp
-
15pcbnew/classpcb.cpp
-
36polygon/math_for_graphics.cpp
-
4polygon/math_for_graphics.h
@ -0,0 +1,399 @@ |
|||
/* |
|||
* This program source code file is part of KICAD, a free EDA CAD application. |
|||
* |
|||
* Copyright (C) 2010 Virtenio GmbH, Torsten Hueter, torsten.hueter <at> virtenio.de |
|||
* Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com> |
|||
* Copyright (C) 2012 Kicad Developers, see change_log.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 VECTOR2D_H_ |
|||
#define VECTOR2D_H_ |
|||
|
|||
#include <cmath> |
|||
#include <wx/gdicmn.h> |
|||
|
|||
|
|||
/// Forward declaration for template friends |
|||
template<class T> class VECTOR2; |
|||
|
|||
/* |
|||
#include <iostream> |
|||
template<class T> ostream& operator<<( ostream &stream, const VECTOR2<T>& vector ); |
|||
*/ |
|||
|
|||
/** |
|||
* Class VECTOR2 |
|||
* defines a general 2D-vector. |
|||
* |
|||
* This class uses templates to be universal. Several operators are provided to help easy implementing |
|||
* of linear algebra equations. |
|||
* |
|||
*/ |
|||
template<class T> class VECTOR2 |
|||
{ |
|||
public: |
|||
T x, y; |
|||
|
|||
// Constructors |
|||
|
|||
/// Construct a 2D-vector with x, y = 0 |
|||
VECTOR2(); |
|||
|
|||
/// Copy constructor |
|||
VECTOR2( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Constructor with a wxPoint as argument |
|||
VECTOR2( const wxPoint& aPoint ); |
|||
|
|||
/// Constructor with a wxSize as argument |
|||
VECTOR2( const wxSize& aSize ); |
|||
|
|||
/// Construct a vector with given components x, y |
|||
VECTOR2( T x, T y ); |
|||
|
|||
/// Destructor |
|||
// virtual ~VECTOR2(); |
|||
|
|||
/** |
|||
* Function Euclidean Norm |
|||
* computes the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2). |
|||
* It is used to calculate the length of the vector. |
|||
* @return Scalar, the euclidean norm |
|||
*/ |
|||
T EuclideanNorm(); |
|||
|
|||
/** |
|||
* Function Perpendicular |
|||
* computes the perpendicular vector |
|||
* @return Perpendicular vector |
|||
*/ |
|||
VECTOR2<T> Perpendicular(); |
|||
|
|||
/** |
|||
* Function Angle |
|||
* computes the angle of the vector |
|||
* @return vector angle |
|||
*/ |
|||
T Angle(); |
|||
|
|||
// Operators |
|||
|
|||
/// Assignment operator |
|||
VECTOR2<T>& operator=( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Vector addition operator |
|||
VECTOR2<T> operator+( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Compound assignment operator |
|||
VECTOR2<T>& operator+=( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Vector subtraction operator |
|||
VECTOR2<T> operator-( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Compound assignment operator |
|||
VECTOR2<T>& operator-=( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Negate Vector operator |
|||
VECTOR2<T> operator-(); |
|||
|
|||
/// Scalar product operator |
|||
T operator*( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Multiplication with a factor |
|||
VECTOR2<T> operator*( const T& aFactor ); |
|||
|
|||
/// Cross product operator |
|||
T operator^( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Equality operator |
|||
const bool operator==( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Not equality operator |
|||
const bool operator!=( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Smaller than operator |
|||
bool operator<( const VECTOR2<T>& aVector ); |
|||
bool operator<=( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Greater than operator |
|||
bool operator>( const VECTOR2<T>& aVector ); |
|||
bool operator>=( const VECTOR2<T>& aVector ); |
|||
|
|||
/// Casting to int vector |
|||
// operator VECTOR2<int>(); |
|||
|
|||
/// Type casting operator for the class wxPoint |
|||
//operator wxPoint(); |
|||
|
|||
// friend ostream& operator<< <T> ( ostream &stream, const VECTOR2<T>& vector ); |
|||
}; |
|||
|
|||
|
|||
// ---------------------- |
|||
// --- Implementation --- |
|||
// ---------------------- |
|||
|
|||
template<class T> VECTOR2<T>::VECTOR2( VECTOR2<T> const& aVector ) : |
|||
x( aVector.x ), y( aVector.y ) |
|||
{ |
|||
} |
|||
|
|||
template<class T> VECTOR2<T>::VECTOR2() |
|||
{ |
|||
x = y = 0.0; |
|||
} |
|||
|
|||
template<class T> VECTOR2<T>::VECTOR2( wxPoint const& aPoint ) |
|||
{ |
|||
x = T( aPoint.x ); |
|||
y = T( aPoint.y ); |
|||
} |
|||
|
|||
template<class T> VECTOR2<T>::VECTOR2( wxSize const& aSize ) |
|||
{ |
|||
x = T( aSize.x ); |
|||
y = T( aSize.y ); |
|||
} |
|||
|
|||
template<class T> VECTOR2<T>::VECTOR2( T aX, T aY ) |
|||
{ |
|||
x = aX; |
|||
y = aY; |
|||
} |
|||
|
|||
// Not required at the moment for this class |
|||
//template<class T> VECTOR2<T>::~VECTOR2() |
|||
//{ |
|||
// // TODO Auto-generated destructor stub |
|||
//} |
|||
|
|||
template<class T> T VECTOR2<T>::EuclideanNorm() |
|||
{ |
|||
return sqrt( ( *this ) * ( *this ) ); |
|||
} |
|||
|
|||
template<class T> T VECTOR2<T>::Angle() |
|||
{ |
|||
return atan2(y, x); |
|||
} |
|||
|
|||
template<class T> VECTOR2<T> VECTOR2<T>::Perpendicular(){ |
|||
VECTOR2<T> perpendicular(-y, x); |
|||
return perpendicular; |
|||
} |
|||
|
|||
/* |
|||
template<class T> ostream &operator<<( ostream &aStream, const VECTOR2<T>& aVector ) |
|||
{ |
|||
aStream << "[ " << aVector.x << " | " << aVector.y << " ]"; |
|||
return aStream; |
|||
} |
|||
*/ |
|||
|
|||
template<class T> VECTOR2<T> &VECTOR2<T>::operator=( const VECTOR2<T>& aVector ) |
|||
{ |
|||
x = aVector.x; |
|||
y = aVector.y; |
|||
return *this; |
|||
} |
|||
|
|||
template<class T> VECTOR2<T> &VECTOR2<T>::operator+=( const VECTOR2<T>& aVector ) |
|||
{ |
|||
x += aVector.x; |
|||
y += aVector.y; |
|||
return *this; |
|||
} |
|||
|
|||
template<class T> VECTOR2<T>& VECTOR2<T>::operator-=( const VECTOR2<T>& aVector ) |
|||
{ |
|||
x -= aVector.x; |
|||
y -= aVector.y; |
|||
return *this; |
|||
} |
|||
|
|||
//template<class T> VECTOR2<T>::operator wxPoint() |
|||
//{ |
|||
// wxPoint point; |
|||
// point.x = (int) x; |
|||
// point.y = (int) y; |
|||
// return point; |
|||
//} |
|||
// |
|||
|
|||
//// Use correct rounding for casting to wxPoint |
|||
//template<> VECTOR2<double>::operator wxPoint() |
|||
//{ |
|||
// wxPoint point; |
|||
// point.x = point.x >= 0 ? (int) ( x + 0.5 ) : (int) ( x - 0.5 ); |
|||
// point.y = point.y >= 0 ? (int) ( y + 0.5 ) : (int) ( y - 0.5 ); |
|||
// return point; |
|||
//} |
|||
|
|||
// Use correct rounding for casting double->int |
|||
//template<> VECTOR2<double>::operator VECTOR2<int>() |
|||
//{ |
|||
// VECTOR2<int> vector; |
|||
// vector.x = vector.x >= 0 ? (int) ( x + 0.5 ) : (int) ( x - 0.5 ); |
|||
// vector.y = vector.y >= 0 ? (int) ( y + 0.5 ) : (int) ( y - 0.5 ); |
|||
// return vector; |
|||
//} |
|||
|
|||
template<class T> VECTOR2<T> VECTOR2<T>::operator+( const VECTOR2<T>& aVector ) |
|||
{ |
|||
return VECTOR2<T> ( x + aVector.x, y + aVector.y ); |
|||
} |
|||
|
|||
template<class T> VECTOR2<T> VECTOR2<T>::operator-( const VECTOR2<T>& aVector ) |
|||
{ |
|||
return VECTOR2<T> ( x - aVector.x, y - aVector.y ); |
|||
} |
|||
|
|||
template<class T> VECTOR2<T> VECTOR2<T>::operator-() |
|||
{ |
|||
return VECTOR2<T> ( -x, -y ); |
|||
} |
|||
|
|||
template<class T> T VECTOR2<T>::operator*( const VECTOR2<T>& aVector ) |
|||
{ |
|||
return aVector.x * x + aVector.y * y; |
|||
} |
|||
|
|||
template<class T> VECTOR2<T> VECTOR2<T>::operator*( const T& aFactor ) |
|||
{ |
|||
VECTOR2<T> vector( x * aFactor, y * aFactor ); |
|||
return vector; |
|||
} |
|||
|
|||
template<class T> VECTOR2<T> operator*( const T& aFactor, const VECTOR2<T>& aVector){ |
|||
VECTOR2<T> vector( aVector.x * aFactor, aVector.y * aFactor ); |
|||
return vector; |
|||
} |
|||
|
|||
template<class T> T VECTOR2<T>::operator^( const VECTOR2<T>& aVector ) |
|||
{ |
|||
return x * aVector.y - y * aVector.x; |
|||
} |
|||
|
|||
template<class T> bool VECTOR2<T>::operator<( const VECTOR2<T>& o ) |
|||
{ |
|||
// VECTOR2<T> vector( aVector ); |
|||
return (double( x ) * x + double( y ) * y) < (double( o.x ) * o.x + double( o.y ) * y); |
|||
} |
|||
|
|||
template<class T> bool VECTOR2<T>::operator<=( const VECTOR2<T>& aVector ) |
|||
{ |
|||
VECTOR2<T> vector( aVector ); |
|||
return ( *this * *this ) <= ( vector * vector ); |
|||
} |
|||
|
|||
template<class T> bool VECTOR2<T>::operator>( const VECTOR2<T>& aVector ) |
|||
{ |
|||
VECTOR2<T> vector( aVector ); |
|||
return ( *this * *this ) > ( vector * vector ); |
|||
} |
|||
|
|||
template<class T> bool VECTOR2<T>::operator>=( const VECTOR2<T>& aVector ) |
|||
{ |
|||
VECTOR2<T> vector( aVector ); |
|||
return ( *this * *this ) >= ( vector * vector ); |
|||
} |
|||
|
|||
template<class T> bool const VECTOR2<T>::operator==( VECTOR2<T> const& aVector ) |
|||
{ |
|||
return ( aVector.x == x ) && ( aVector.y == y ); |
|||
} |
|||
|
|||
template<class T> bool const VECTOR2<T>::operator!=( VECTOR2<T> const& aVector ) |
|||
{ |
|||
return ( aVector.x != x ) || ( aVector.y != y ); |
|||
} |
|||
|
|||
|
|||
/** |
|||
* Class RECT |
|||
* is a description of a rectangle in cartesion coordinate system. |
|||
*/ |
|||
template<class T> class RECT |
|||
{ |
|||
public: |
|||
RECT() : x(0), y(0), width(0), height(0) {} |
|||
|
|||
RECT( T aX, T aY, T aWidth, T aHeight ): |
|||
x( aX ), y( aY ), width( aWidth ), height( aHeight ) |
|||
{} |
|||
|
|||
|
|||
/// Copy constructor |
|||
RECT( const RECT<T>& aRect ) : |
|||
x( aRect.x ), y( aRect.y ), width( aRect.width ), height( aRect.height ) |
|||
{} |
|||
|
|||
/// Constructor with a wxPoint as argument? |
|||
|
|||
VECTOR2<T> GetSize() const { return VECTOR2<T> ( width, height ); } |
|||
VECTOR2<T> GetPosition() const { return VECTOR2<T> ( x, y ); } |
|||
|
|||
T GetLeft() const { return x; } |
|||
void SetLeft( T n ) { width += x - n; x = n; } |
|||
void MoveLeftTo( T n ) { x = n; } |
|||
|
|||
T GetTop() const { return y; } |
|||
void SetTop( T n ) { height += y - n; y = n; } |
|||
void MoveTopTo( T n ) { y = n; } |
|||
|
|||
T GetBottom() const { return y + height; } |
|||
void SetBottom( T n ) { height += n - ( y + height ); } |
|||
void MoveBottomTo( T n ) { y = n - height; } |
|||
|
|||
T GetRight() const { return x + width; } |
|||
void SetRight( T n ) { width += n - ( x + width ); } |
|||
void MoveRightTo( T n ) { x = n - width; } |
|||
|
|||
VECTOR2<T> GetLeftTop() const { return VECTOR2<T>( x , y ); } |
|||
void SetLeftTop( const VECTOR2<T>& pt ) { width += x - pt.x; height += y - pt.y; x = pt.x; y = pt.y; } |
|||
void MoveLeftTopTo( const VECTOR2<T> &pt ) { x = pt.x; y = pt.y; } |
|||
|
|||
VECTOR2<T> GetLeftBottom() const { return VECTOR2<T>( x, y + height ); } |
|||
void SetLeftBottom( const VECTOR2<T>& pt ) { width += x - pt.x; height += pt.y - (y + height); x = pt.x; } |
|||
void MoveLeftBottomTo( const VECTOR2<T>& pt ) { x = pt.x; y = pt.y - height; } |
|||
|
|||
VECTOR2<T> GetRightTop() const { return VECTOR2<T>( x + width, y ); } |
|||
void SetRightTop( const VECTOR2<T>& pt ) { width += pt.x - ( x + width ); height += y - pt.y; y = pt.y; } |
|||
void MoveRightTopTo( const VECTOR2<T>& pt ) { x = pt.x - width; y = pt.y; } |
|||
|
|||
VECTOR2<T> GetRightBottom() const { return VECTOR2<T>( x + width, y + height ); } |
|||
void SetRightBottom( const VECTOR2<T>& pt ) { width += pt.x - ( x + width ); height += pt.y - ( y + height); } |
|||
void MoveRightBottomTo( const VECTOR2<T>& pt ) { x = pt.x - width; y = pt.y - height; } |
|||
|
|||
VECTOR2<T> GetCentre() const { return VECTOR2<T>( x + width/2, y + height/2 ); } |
|||
void SetCentre( const VECTOR2<T>& pt ) { MoveCentreTo( pt ); } |
|||
void MoveCentreTo( const VECTOR2<T>& pt ) { x += pt.x - (x + width/2), y += pt.y - (y + height/2); } |
|||
|
|||
T x, y, width, height; |
|||
}; |
|||
|
|||
|
|||
typedef VECTOR2<double> DPOINT; |
|||
typedef DPOINT DSIZE; |
|||
|
|||
typedef RECT<double> DRECT; |
|||
|
|||
|
|||
#endif // VECTOR2D_H_ |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue