iLab Neuromorphic Robotics Toolkit  0.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
RangeImpl.H
Go to the documentation of this file.
1 /*! @file
2  @author Laurent Itti
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 
39 
40 #include <boost/lexical_cast.hpp>
41 
42 // ######################################################################
43 // Inline function implementations
44 // ######################################################################
45 template <class T> inline
47  itsMin(0), itsMax(0)
48 { }
49 
50 // ######################################################################
51 template <class T> inline
52 nrt::Range<T>::Range(T const mini, T const maxi) :
53  itsMin(mini), itsMax(maxi)
54 {
55  if (itsMax < itsMin) std::swap(itsMin, itsMax);
56 }
57 
58 // ######################################################################
59 template <class T> template <class U> inline
61  itsMin(nrt::clamped_convert<T,U>(other.min())),
62  itsMax(nrt::clamped_convert<T,U>(other.max()))
63  { }
64 
65 // ######################################################################
66 template <class T> inline
67 T const & nrt::Range<T>::min() const
68 { return itsMin; }
69 
70 // ######################################################################
71 template <class T> inline
72 T const & nrt::Range<T>::max() const
73 { return itsMax; }
74 
75 // ######################################################################
76 template <class T> inline
77 bool const nrt::Range<T>::empty() const
78 { return (itsMax == itsMin); }
79 
80 
81 // ######################################################################
82 template <class T> inline
83 void nrt::Range<T>::extend(T const val)
84 {
85  if (itsMax < val) itsMax = val;
86  if (val < itsMin) itsMin = val;
87 }
88 
89 // ######################################################################
90 // Free function implementations
91 // ######################################################################
92 template <class T> inline
93 nrt::Range<T> nrt::merge(nrt::Range<T> const & r1, nrt::Range<T> const & r2)
94 {
95  return nrt::Range<T>(std::min(r1.min(), r2.min()), std::max(r1.max(), r2.max()));
96 }
97 
98 // ######################################################################
99 template <class T> inline
100 std::ostream & nrt::operator<<(std::ostream & out, nrt::Range<T> const & r)
101 { return out << r.min() << "-" << r.max(); }
102 
103 // ######################################################################
104 template <class T> inline
105 std::istream & nrt::operator>>(std::istream & in, nrt::Range<T> & r)
106 {
107  std::string stringRep; in >> stringRep;
108  std::vector<std::string> splitVec = nrt::splitString(stringRep, '-');
109 
110  if (splitVec.size() != 2)
111  throw nrt::exception::Exception(std::string("Could Not Parse Range From ["+stringRep+']').c_str());
112 
113  T mi = 0, ma = 0;
114  try
115  {
116  mi = boost::lexical_cast<T>(splitVec[0]);
117  ma = boost::lexical_cast<T>(splitVec[1]);
118  }
119  catch (boost::bad_lexical_cast &)
120  {
121  throw nrt::exception::Exception(std::string("Could Not Parse Range From ["+stringRep+']').c_str());
122  }
123 
124  r = nrt::Range<T>(mi, ma);
125 
126  return in;
127 }
128 
129 // ######################################################################
130 template <class T> inline
131 void nrt::paramValToString(nrt::Range<T> const & val, std::string & result)
132 { std::stringstream out; out << val.min() << "-" << val.max(); result = out.str(); }
133 
134 // ######################################################################
135 template <class T> inline
136 void nrt::paramStringToVal(std::string const & valstring, nrt::Range<T> & result)
137 {
138  std::vector<std::string> splitVec = nrt::splitString(valstring, '-');
139 
140  if (splitVec.size() != 2)
141  throw nrt::exception::Exception(std::string("Could Not Parse Range From ["+valstring+']').c_str());
142 
143  T mi = 0, ma = 0;
144  try { mi = boost::lexical_cast<T>(splitVec[0]); ma = boost::lexical_cast<T>(splitVec[1]); }
145  catch (boost::bad_lexical_cast & e)
146  { throw nrt::exception::Exception(std::string("Could Not Parse Range From ["+valstring+"]: " + e.what()).c_str()); }
147 
148  result = nrt::Range<T>(mi, ma);
149 }
150 
151 // ######################################################################
152 template <class T> inline
153 bool nrt::operator==(nrt::Range<T> const & range1, nrt::Range<T> const & range2)
154 { return (range1.min() == range2.min()) && (range1.max() == range2.max()); }
155 
156 // ######################################################################
157 template <class T> inline
158 bool nrt::operator!=(nrt::Range<T> const & range1, nrt::Range<T> const & range2)
159 { return (range1.min() != range2.min()) || (range1.max() != range2.max()); }
160 
161 // ######################################################################
162 template <class T> inline
163 nrt::Range<T> nrt::operator+(nrt::Range<T> const & range, T const & scalar)
164 { return nrt::Range<T>(range.min() + scalar, range.max() + scalar); }
165 
166 // ######################################################################
167 template <class T> inline
168 nrt::Range<T> nrt::operator+(T const & scalar, nrt::Range<T> const & range)
169 { return nrt::Range<T>(scalar + range.min(), scalar + range.max()); }
170 
171 // ######################################################################
172 template <class T> inline
173 nrt::Range<T> nrt::operator-(nrt::Range<T> const & range, T const & scalar)
174 { return nrt::Range<T>(range.min() - scalar, range.max() - scalar); }
175 
176 // ######################################################################
177 template <class T> inline
178 nrt::Range<T> nrt::operator-(T const & scalar, nrt::Range<T> const & range)
179 { return nrt::Range<T>(scalar - range.min(), scalar - range.max()); }
180 
181 // ######################################################################
182 template <class T> inline
183 nrt::Range<T> nrt::operator/(nrt::Range<T> const & range, T const & scalar)
184 { return nrt::Range<T>(range.min() / scalar, range.max() / scalar); }
185 
186 // ######################################################################
187 template <class T> inline
188 nrt::Range<T> nrt::operator/(T const & scalar, nrt::Range<T> const & range)
189 { return nrt::Range<T>(scalar / range.min(), scalar / range.max()); }
190 
191 // ######################################################################
192 template <class T> inline
193 nrt::Range<T> nrt::operator*(nrt::Range<T> const & range, T const & scalar)
194 { return nrt::Range<T>(range.min() * scalar, range.max() * scalar); }
195 
196 // ######################################################################
197 template <class T> inline
198 nrt::Range<T> nrt::operator*(T const & scalar, nrt::Range<T> const & range)
199 { return nrt::Range<T>(scalar * range.min(), scalar * range.max()); }
200 
201 // ######################################################################
202 template <class T> inline
203 nrt::Range<T> & nrt::operator+=(nrt::Range<T> & range, T const & scalar)
204 { return range = nrt::Range<T>(range.min() + scalar, range.max() + scalar); }
205 
206 // ######################################################################
207 template <class T> inline
208 nrt::Range<T> & nrt::operator-=(nrt::Range<T> & range, T const & scalar)
209 { return range = nrt::Range<T>(range.min() - scalar, range.max() - scalar); }
210 
211 // ######################################################################
212 template <class T> inline
213 nrt::Range<T> & nrt::operator*=(nrt::Range<T> & range, T const & scalar)
214 { return range = nrt::Range<T>(range.min() * scalar, range.max() * scalar); }
215 
216 // ######################################################################
217 template <class T> inline
218 nrt::Range<T> & nrt::operator/=(nrt::Range<T> & range, T const & scalar)
219 { return range = nrt::Range<T>(range.min() / scalar, range.max() / scalar); }
220