iLab Neuromorphic Robotics Toolkit  0.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Array2DImpl.H
Go to the documentation of this file.
1 /*! @file
2  @author Randolph Voorhies
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 // ######################################################################
37 template <class T> inline
39  itsDims(0,0),
40  itsArray()
41 { }
42 
43 // ######################################################################
44 template <class T> inline
45 nrt::Array2D<T>::Array2D(DimsType const & dims) :
46  itsDims(dims),
47  itsArray(itsDims.width() * itsDims.height())
48 { }
49 
50 // ######################################################################
51 template <class T> inline
52 nrt::Array2D<T>::Array2D(DimsType const & dims, T const & val) :
53  itsDims(dims),
54  itsArray(itsDims.width() * itsDims.height(), val)
55 { }
56 
57 // ######################################################################
58 template <class T> inline
60 {
61  if (&other == this) return;
62  itsDims = other.itsDims;
63  itsArray = other.itsArray;
64 }
65 
66 // ######################################################################
67 template <class T> inline
69 {
70  if (&other == this) return;
71  itsDims = std::move(other.itsDims);
72  itsArray = std::move(other.itsArray);
73 }
74 
75 // ######################################################################
76 template <class T> inline
77 nrt::Array2D<T>::Array2D(std::initializer_list<std::initializer_list<T> > vals) :
78  itsDims(vals.size() > 0 ? vals.begin()->size() : 0, vals.size()),
79  itsArray(itsDims.width()*itsDims.height())
80 {
81  Array2D<T>::iterator dest = begin();
82  for (std::initializer_list<T> const & v : vals)
83  for (T const & vv : v)
84  *dest++ = vv;
85 }
86 
87 // ######################################################################
88 template <class T> inline
89 nrt::Array2D<T>::Array2D(T const * data, DimsType const & dims) :
90  itsDims(dims),
91  itsArray(data, dims.width() * dims.height())
92 { }
93 
94 // ######################################################################
95 template <class T> inline
97 {
98  if (&other != this)
99  {
100  itsDims = other.itsDims;
101  itsArray = other.itsArray;
102  }
103  return *this;
104 }
105 
106 // ######################################################################
107 template <class T> inline
109 {
110  if (&other != this)
111  {
112  itsDims = std::move(other.itsDims);
113  itsArray = std::move(other.itsArray);
114  }
115  return *this;
116 }
117 
118 // ######################################################################
119 template <class T> inline
120 void nrt::Array2D<T>::clear(T const & val)
121 { for (T & pix : itsArray) pix = val; }
122 
123 // ######################################################################
124 template <class T> inline
125 T & nrt::Array2D<T>::operator()(nrt::int32 x, nrt::int32 y)
126 {
127  return this->begin()[y*itsDims.width() + x];
128 }
129 
130 // ######################################################################
131 template <class T> inline
132 T const & nrt::Array2D<T>::operator()(nrt::int32 x, nrt::int32 y) const
133 { return at(x,y); }
134 
135 // ######################################################################
136 template <class T> inline
138 { return this->operator()(p.x(), p.y()); }
139 
140 // ######################################################################
141 template <class T> inline
143 { return at(p); }
144 
145 // ######################################################################
146 template <class T> inline
148 {
149  return this->begin()[idx];
150 }
151 
152 // ######################################################################
153 template <class T> inline
154 T const & nrt::Array2D<T>::operator()(uint32 idx) const
155 { return at(idx); }
156 
157 // ######################################################################
158 template <class T> inline
159 T const & nrt::Array2D<T>::at(nrt::int32 x, nrt::int32 y) const
160 {
161  return this->const_begin()[y*itsDims.width() + x];
162 }
163 
164 // ######################################################################
165 template <class T> inline
167 { return this->at(p.x(), p.y()); }
168 
169 // ######################################################################
170 template <class T> inline
171 T const & nrt::Array2D<T>::at(uint32 idx) const
172 {
173  return this->const_begin()[idx];
174 }
175 
176 // ######################################################################
177 template <class T>
178 template <class U> inline
179 bool nrt::Array2D<T>::coordsOk(const U x, const U y) const
180 {
181  return (x >= 0 && y >= 0 && x < width() && y < height());
182 }
183 
184 // ######################################################################
185 template <class T>
186 template <class U> inline
188 {
189  return (coordsOk(rect.topLeft()) && coordsOk(rect.bottomRight()));
190 }
191 
192 // ######################################################################
193 template <class T>
194 template <class U> inline
196 {
197  return (P.x() >= 0 && P.y() >= 0 && P.x() < width() && P.y() < height());
198 }
199 
200 // ######################################################################
201 template <class T> inline
203 { return itsDims; }
204 
205 // ######################################################################
206 template <class T> inline
209 
210 // ######################################################################
211 template <class T> inline
212 nrt::int32 const nrt::Array2D<T>::width() const
213 { return itsDims.width(); }
214 
215 // ######################################################################
216 template <class T> inline
217 nrt::int32 const nrt::Array2D<T>::height() const
218 { return itsDims.height(); }
219 
220 // ######################################################################
221 template <class T> inline
222 nrt::int32 const nrt::Array2D<T>::size() const
223 { return itsArray.size(); }
224 
225 // ######################################################################
226 template <class T> inline
227 bool const nrt::Array2D<T>::empty() const
228 { return (itsArray.size() == 0); }
229 
230 // ######################################################################
231 template <class T> inline
233 {
234  if (newdims.size() != size()) throw nrt::exception::BadDimsArray2DException(newdims);
235  itsDims = newdims;
236 }
237 
238 // ######################################################################
239 template <class T> inline
240 void nrt::Array2D<T>::reshape(int32 newWidth, int32 newHeight)
241 { reshape(nrt::Dims<nrt::int32>(newWidth, newHeight)); }
242 
243 // ######################################################################
244 template <class T> inline
246 { return *this; }
247 
248 // ######################################################################
249 template <class T> inline
251 { return itsArray.begin(); }
252 
253 // ######################################################################
254 template <class T> inline
256 { return itsArray.end(); }
257 
258 // ######################################################################
259 template <class T> inline
261 { return itsArray.const_begin(); }
262 
263 // ######################################################################
264 template <class T> inline
266 { return itsArray.const_begin(); }
267 
268 // ######################################################################
269 template <class T> inline
271 { return itsArray.const_end(); }
272 
273 // ######################################################################
274 template <class T> inline
276 { return itsArray.const_end(); }
277 
278 // ######################################################################
279 template <class T> inline
281 { itsArray.deepCopy(); }