Created by the British Broadcasting Corporation.
00001 /* ***** BEGIN LICENSE BLOCK ***** 00002 * 00003 * $Id: arrays.h,v 1.11 2004/11/29 12:54:54 asuraparaju Exp $ $Name: Dirac_0_5_1 $ 00004 * 00005 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 00006 * 00007 * The contents of this file are subject to the Mozilla Public License 00008 * Version 1.1 (the "License"); you may not use this file except in compliance 00009 * with the License. You may obtain a copy of the License at 00010 * http://www.mozilla.org/MPL/ 00011 * 00012 * Software distributed under the License is distributed on an "AS IS" basis, 00013 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for 00014 * the specific language governing rights and limitations under the License. 00015 * 00016 * The Original Code is BBC Research and Development code. 00017 * 00018 * The Initial Developer of the Original Code is the British Broadcasting 00019 * Corporation. 00020 * Portions created by the Initial Developer are Copyright (C) 2004. 00021 * All Rights Reserved. 00022 * 00023 * Contributor(s): Thomas Davies (Original Author), Peter Meerwald (pmeerw@users.sourceforge.net) 00024 * 00025 * Alternatively, the contents of this file may be used under the terms of 00026 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser 00027 * Public License Version 2.1 (the "LGPL"), in which case the provisions of 00028 * the GPL or the LGPL are applicable instead of those above. If you wish to 00029 * allow use of your version of this file only under the terms of the either 00030 * the GPL or LGPL and not to allow others to use your version of this file 00031 * under the MPL, indicate your decision by deleting the provisions above 00032 * and replace them with the notice and other provisions required by the GPL 00033 * or LGPL. If you do not delete the provisions above, a recipient may use 00034 * your version of this file under the terms of any one of the MPL, the GPL 00035 * or the LGPL. 00036 * ***** END LICENSE BLOCK ***** */ 00037 00038 #ifndef _ARRAYS_H_ 00039 #define _ARRAYS_H_ 00040 00041 //basic array types used for pictures etc 00042 00043 #include <memory> 00044 #include <cstddef> 00045 #include <stdexcept> 00046 #include <iostream> 00047 #include <algorithm> 00048 00049 namespace dirac 00050 { 00051 typedef short ValueType; 00052 typedef int CalcValueType; 00053 00055 00059 class Range 00060 { 00061 public: 00063 00066 Range(int s, int e): m_fst(s), m_lst(e){} 00067 00069 const int First() const {return m_fst;} 00070 00072 const int Last() const {return m_lst;} 00073 00074 private: 00075 int m_fst ,m_lst; 00076 }; 00077 00079 //One-Dimensional Array type// 00081 00083 00088 template <class T> class OneDArray 00089 { 00090 public: 00092 00095 OneDArray(); 00096 00098 00101 OneDArray(const int len); 00102 00104 00109 OneDArray(const Range& r); 00110 00112 00115 ~OneDArray() 00116 { 00117 FreePtr(); 00118 } 00119 00121 00124 OneDArray(const OneDArray<T>& cpy); 00125 00127 00130 OneDArray<T>& operator=(const OneDArray<T>& rhs); 00131 00133 void Resize(int l); 00134 00136 T& operator[](const int pos){return m_ptr[pos-m_first];} 00137 00139 const T& operator[](const int pos) const {return m_ptr[pos-m_first];} 00140 00142 int Length() const {return m_length;} 00143 00145 int First() const {return m_first;} 00146 00148 int Last() const {return m_last;} 00149 00150 private: 00151 void Init(const int len); 00152 00153 void Init(const Range& r); 00154 00155 void FreePtr(); 00156 00157 int m_first, m_last; 00158 int m_length; 00159 T* m_ptr; 00160 }; 00161 00162 //public member functions// 00164 00165 template <class T> 00166 OneDArray<T>::OneDArray() 00167 { 00168 Init(0); 00169 } 00170 00171 template <class T> 00172 OneDArray<T>::OneDArray(const int len) 00173 { 00174 Init(len); 00175 } 00176 00177 template <class T> 00178 OneDArray<T>::OneDArray(const Range& r) 00179 { 00180 Init(r); 00181 } 00182 00183 template <class T> 00184 OneDArray<T>::OneDArray(const OneDArray<T>& cpy) 00185 { 00186 m_first = cpy.m_first; 00187 m_last = cpy.m_last; 00188 m_length = m_last - m_first + 1; 00189 00190 if (m_first==0) 00191 Init(m_length); 00192 else 00193 Init(Range(m_first , m_last)); 00194 00195 memcpy( m_ptr , cpy.m_ptr , m_length * sizeof( T ) ); 00196 } 00197 00198 template <class T> 00199 OneDArray<T>& OneDArray<T>::operator=(const OneDArray<T>& rhs) 00200 { 00201 if (&rhs != this) 00202 { 00203 FreePtr(); 00204 m_first = rhs.m_first; 00205 m_last = rhs.m_last; 00206 m_length = rhs.m_length; 00207 00208 if (m_first == 0) 00209 Init(m_length); 00210 else 00211 Init(Range(m_first , m_last)); 00212 00213 memcpy( m_ptr , rhs.m_ptr , m_length * sizeof( T ) ); 00214 00215 } 00216 return *this; 00217 } 00218 00219 template <class T> 00220 void OneDArray<T>::Resize(int l) 00221 { 00222 FreePtr(); 00223 Init(l); 00224 } 00225 00226 //private member functions// 00228 00229 template <class T> 00230 void OneDArray<T>::Init(const int len) 00231 { 00232 Range r(0 , len-1); 00233 00234 Init(r); 00235 00236 } 00237 00238 template <class T> 00239 void OneDArray<T>::Init(const Range& r) 00240 { 00241 00242 m_first = r.First(); 00243 m_last = r.Last(); 00244 m_length = m_last - m_first + 1; 00245 00246 if ( m_length>0 ) 00247 { 00248 m_ptr = new T[ m_length ]; 00249 } 00250 else 00251 { 00252 m_length = 0; 00253 m_first = 0; 00254 m_last = -1; 00255 } 00256 } 00257 00258 template <class T> 00259 void OneDArray<T>::FreePtr() 00260 { 00261 if ( m_length>0 ) 00262 delete[] m_ptr; 00263 } 00264 00265 00267 //Two-Dimensional Array type// 00269 00271 00278 template <class T> class TwoDArray 00279 { 00280 typedef T* element_type; 00281 00282 public: 00283 00285 00288 TwoDArray(){ Init(0,0); } 00289 00291 00294 TwoDArray( const int height , const int width ){Init(height , width);} 00295 00297 00301 TwoDArray( const int height , const int width , T val); 00302 00304 00307 virtual ~TwoDArray(){ 00308 FreeData(); 00309 } 00310 00312 00315 TwoDArray(const TwoDArray<T>& Cpy); 00316 00318 00321 TwoDArray<T>& operator=(const TwoDArray<T>& rhs); 00322 00324 void Resize(const int height, const int width); 00325 00327 00331 inline element_type& operator[](const int pos){return m_array_of_rows[pos];} 00332 00334 00338 inline const element_type& operator[](const int pos) const {return m_array_of_rows[pos];} 00339 00341 const int LengthX() const { return m_length_x; } 00342 00344 const int LengthY() const { return m_length_y; } 00345 00347 const int FirstX() const { return m_first_x; } 00348 00350 const int FirstY() const { return m_first_y; } 00351 00353 const int LastX() const { return m_last_x; } 00354 00356 const int LastY() const { return m_last_y; } 00357 00358 private: 00360 void Init(const int height,const int width); 00361 00363 void FreeData(); 00364 00365 int m_first_x; 00366 int m_first_y; 00367 00368 int m_last_x; 00369 int m_last_y; 00370 00371 int m_length_x; 00372 int m_length_y; 00373 00374 element_type* m_array_of_rows; 00375 }; 00376 00377 //public member functions// 00379 00380 template <class T> 00381 TwoDArray<T>::TwoDArray( const int height , const int width , const T val) 00382 { 00383 Init( height , width ); 00384 for (int j=0 ; j<m_length_y ; ++j) 00385 std::fill_n( m_array_of_rows[j] , m_length_x , val); 00386 } 00387 00388 template <class T> 00389 TwoDArray<T>::TwoDArray(const TwoDArray<T>& Cpy) 00390 { 00391 m_first_x = Cpy.m_first_x; 00392 m_first_y = Cpy.m_first_y; 00393 m_last_x = Cpy.m_last_x; 00394 m_last_y = Cpy.m_last_y; 00395 00396 m_length_x = m_last_x - m_first_x + 1; 00397 m_length_y = m_last_y - m_first_y + 1; 00398 00399 if (m_first_x == 0 && m_first_y == 0) 00400 Init(m_length_y , m_length_x); 00401 else{ 00402 //based 2D arrays not yet supported 00403 } 00404 for (int j=0 ; j<m_length_y ; ++j) 00405 memcpy( m_array_of_rows[j] , (Cpy.m_array_of_rows)[j] , m_length_x * sizeof( T ) ); 00406 00407 } 00408 00409 template <class T> 00410 TwoDArray<T>& TwoDArray<T>::operator=(const TwoDArray<T>& rhs) 00411 { 00412 if (&rhs != this) 00413 { 00414 FreeData(); 00415 00416 m_first_x = rhs.m_first_x; 00417 m_first_y = rhs.m_first_y; 00418 00419 m_last_x = rhs.m_last_x; 00420 m_last_y = rhs.m_last_y; 00421 00422 m_length_x = m_last_x - m_first_x + 1; 00423 m_length_y = m_last_y - m_first_y + 1; 00424 00425 if (m_first_x == 0 && m_first_y == 0) 00426 Init(m_length_y , m_length_x); 00427 else 00428 { 00429 //based 2D arrays not yet supported 00430 } 00431 00432 for ( int j=0 ; j<m_length_y; ++j) 00433 memcpy( m_array_of_rows[j] , (rhs.m_array_of_rows)[j] , m_length_x * sizeof( T ) ); 00434 00435 } 00436 00437 return *this; 00438 00439 } 00440 00441 template <class T> 00442 void TwoDArray<T>::Resize(const int height, const int width) 00443 { 00444 FreeData(); 00445 Init(height , width); 00446 } 00447 00448 //private member functions// 00450 00451 template <class T> 00452 void TwoDArray<T>::Init(const int height , const int width) 00453 { 00454 m_length_x = width; 00455 m_length_y = height; 00456 m_first_x = 0; 00457 m_first_y = 0; 00458 00459 m_last_x = m_length_x-1; 00460 m_last_y = m_length_y-1; 00461 00462 if (m_length_y>0) 00463 { 00464 // allocate the array containing ptrs to all the rows 00465 m_array_of_rows = new element_type[ m_length_y ]; 00466 00467 if ( m_length_x>0 ) 00468 { 00469 // next, allocate all the rows 00470 for (int j=0 ; j<m_length_y ; ++j) 00471 { 00472 m_array_of_rows[j] = new T[ m_length_x ]; 00473 }// j 00474 } 00475 else 00476 { 00477 m_length_x = 0; 00478 m_first_x = 0; 00479 m_last_x = -1; 00480 } 00481 } 00482 else 00483 { 00484 m_length_x = 0; 00485 m_length_y = 0; 00486 m_first_x = 0; 00487 m_first_y = 0; 00488 m_last_x = -1; 00489 m_last_y = -1; 00490 } 00491 } 00492 00493 template <class T> 00494 void TwoDArray<T>::FreeData() 00495 { 00496 if (m_length_y>0) 00497 { 00498 if (m_length_x>0) 00499 { 00500 // deallocate each row 00501 for (int j=0 ; j<m_length_y ; ++j) 00502 { 00503 delete[] m_array_of_rows[j]; 00504 }// j 00505 } 00506 00507 // deallocate the array of rows 00508 delete[] m_array_of_rows; 00509 } 00510 } 00511 00512 // Related functions 00513 00515 template <class T > 00516 std::ostream & operator<< (std::ostream & stream, TwoDArray<T> & array) 00517 { 00518 for (int j=0 ; j<array.LengthY() ; ++j) 00519 { 00520 for (int i=0 ; i<array.LengthX() ; ++i) 00521 { 00522 stream << array[j][i] << " "; 00523 }// i 00524 stream << std::endl; 00525 }// j 00526 00527 return stream; 00528 } 00529 00531 template <class T > 00532 std::istream & operator>> (std::istream & stream, TwoDArray<T> & array) 00533 { 00534 for (int j=0 ; j<array.LengthY() ; ++j) 00535 { 00536 for (int i=0 ; i<array.LengthX() ; ++i) 00537 { 00538 stream >> array[j][i]; 00539 }// i 00540 }// j 00541 00542 return stream; 00543 } 00544 00545 } //namespace dirac 00546 #endif
© 2004 British Broadcasting Corporation.
Dirac code licensed under the Mozilla Public License (MPL) Version 1.1.
HTML documentation generated by Dimitri van Heesch's
excellent Doxygen tool.