iLab Neuromorphic Robotics Toolkit  0.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CircleImpl.H
Go to the documentation of this file.
1 /*! @file
2  @author Unknown
3  @copyright GNU Public License (GPL v3)
4  @section License
5  @verbatim
6  // ////////////////////////////////////////////////////////////////////////
7  // The iLab Neuromorphic Robotics Toolkit (NRT) //
8  // Copyright 2010-2012 by the University of Southern California (USC) //
9  // and the iLab at USC. //
10  // //
11  // iLab - University of Southern California //
12  // Hedco Neurociences Building, Room HNB-10 //
13  // Los Angeles, Ca 90089-2520 - USA //
14  // //
15  // See http://ilab.usc.edu for information about this project. //
16  // ////////////////////////////////////////////////////////////////////////
17  // This file is part of The iLab Neuromorphic Robotics Toolkit. //
18  // //
19  // The iLab Neuromorphic Robotics Toolkit is free software: you can //
20  // redistribute it and/or modify it under the terms of the GNU General //
21  // Public License as published by the Free Software Foundation, either //
22  // version 3 of the License, or (at your option) any later version. //
23  // //
24  // The iLab Neuromorphic Robotics Toolkit is distributed in the hope //
25  // that it will be useful, but WITHOUT ANY WARRANTY; without even the //
26  // implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
27  // PURPOSE. See the GNU General Public License for more details. //
28  // //
29  // You should have received a copy of the GNU General Public License //
30  // along with The iLab Neuromorphic Robotics Toolkit. If not, see //
31  // <http://www.gnu.org/licenses/>. //
32  // ////////////////////////////////////////////////////////////////////////
33  @endverbatim */
34 
35 // ######################################################################
36 template <class T> inline
38  itsCenter(0,0), itsRadius(0)
39 { }
40 
41 // ######################################################################
42 template <class T> template <class U> inline
44  itsCenter(nrt::clamped_convert<T,U>(other.center())),
45  itsRadius(nrt::clamped_convert<T,U>(other.radius()))
46 { }
47 
48 // ######################################################################
49 template <class T> inline
50 nrt::Circle<T>::Circle(nrt::Point2D<T> const& center, T const& radius) :
51  itsCenter(center), itsRadius(radius)
52 { }
53 
54 // ######################################################################
55 template <class T> inline
56 nrt::Circle<T>::Circle(T cx, T cy, T radius) :
57  itsCenter(cx,cy), itsRadius(radius)
58 { }
59 
60 // ######################################################################
61 template <class T> inline
63 { return itsCenter; }
64 
65 // ######################################################################
66 template <class T> inline
67 T const & nrt::Circle<T>::radius() const
68 { return itsRadius; }
69 
70 // ######################################################################
71 template <class T> inline
72 double nrt::Circle<T>::area() const
73 { return itsRadius*itsRadius*M_PI; }
74 
75 // ######################################################################
76 template <class T> inline
78 { return itsRadius*2.0*M_PI; }
79 
80 // ######################################################################
81 template <class T> template <class U> inline
83 {
84  return (itsCenter.distanceTo(p) <= itsRadius);
85 }
86 
87 // ######################################################################
88 template <class T> inline
89 std::ostream& nrt::operator<<(std::ostream &out, nrt::Circle<T> const& circle)
90 {
91  out << "c:" << circle.center() << " r:" << circle.radius();
92  return out;
93 }
94 
95 // ######################################################################
96 template <class T> inline
97 nrt::Circle<T> nrt::scale(nrt::Circle<T> const & src, double const factor)
98 { return nrt::Circle<T>(src.center(), nrt::clamped_convert<T>(src.radius() * factor)); }
99 
100 // ######################################################################
101 template <class T> inline
102 nrt::Circle<T> nrt::rotate(nrt::Circle<T> const & src, double const angle)
103 { return src; }
104 
105 // #####################################################################
106 template <class T> inline
107 nrt::Circle<T> nrt::rotateAbout(nrt::Circle<T> const & src, nrt::Point2D<T> const & p, double const angle)
108 { return nrt::Circle<T>(nrt::rotateAbout(src.center(), p, angle), src.radius()); }
109 
110 // ######################################################################
111 template <class T> inline
112 bool nrt::operator==(nrt::Circle<T> const & lhs, nrt::Circle<T> const & rhs)
113 { return ((lhs.center() == rhs.center()) && (lhs.radius() == rhs.radius())); }
114 
115 // ######################################################################
116 template <class T> inline
117 bool nrt::operator!=(nrt::Circle<T> const & lhs, nrt::Circle<T> const & rhs)
118 { return ((lhs.center() != rhs.center()) || (lhs.radius() != rhs.radius())); }
119 
120 // ######################################################################
121 template <class T> inline
123 { return nrt::Circle<T>(lhs.center() + rhs, lhs.radius()); }
124 
125 // ######################################################################
126 template <class T> inline
128 { return nrt::Circle<T>(lhs + rhs.center(), rhs.radius()); }
129 
130 // ######################################################################
131 template <class T> inline
133 { return nrt::Circle<T>(lhs.center() - rhs, lhs.radius()); }
134 
135 // ######################################################################
136 template <class T> inline
138 { return nrt::Circle<T>(lhs - rhs.center(), rhs.radius()); }
139 
140 // ######################################################################
141 template <class T> inline
142 nrt::Circle<T> nrt::operator*(nrt::Circle<T> const & lhs, double const rhs)
143 { return nrt::Circle<T>(lhs.center() * rhs, nrt::clamped_convert<T>(lhs.radius() * rhs)); }
144 
145 // ######################################################################
146 template <class T> inline
147 nrt::Circle<T> nrt::operator*(double const lhs, nrt::Circle<T> const & rhs)
148 { return nrt::Circle<T>(lhs * rhs.center(), nrt::clamped_convert<T>(lhs * rhs.radius())); }
149 
150 // ######################################################################
151 template <class T> inline
152 nrt::Circle<T> nrt::operator/(nrt::Circle<T> const & lhs, double const rhs)
153 { return nrt::Circle<T>(lhs.center() / rhs, nrt::clamped_convert<T>(lhs.radius() / rhs)); }
154 
155 // ######################################################################
156 template <class T> inline
157 nrt::Circle<T> & nrt::operator*=(nrt::Circle<T> & lhs, double const rhs)
158 {
159  lhs = nrt::Circle<T>(lhs.center() * rhs, nrt::clamped_convert<T>(lhs.radius() * rhs));
160  return lhs;
161 }
162 
163 // ######################################################################
164 template <class T> inline
165 nrt::Circle<T> & nrt::operator/=(nrt::Circle<T> & lhs, double const rhs)
166 {
167  lhs = nrt::Circle<T>(lhs.center() / rhs, nrt::clamped_convert<T>(lhs.radius() / rhs));
168  return lhs;
169 }
170