Created by the British Broadcasting Corporation.
00001 /* ***** BEGIN LICENSE BLOCK ***** 00002 * 00003 * $Id: arrays.h,v 1.21 2008/03/14 08:17:36 asuraparaju Exp $ $Name: Dirac_1_0_2 $ 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), 00024 * Peter Meerwald (pmeerw@users.sourceforge.net) 00025 * Mike Ferenduros (mike_ferenzduros@users.sourceforge.net) 00026 * Anuradha Suraparaju 00027 * 00028 * Alternatively, the contents of this file may be used under the terms of 00029 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser 00030 * Public License Version 2.1 (the "LGPL"), in which case the provisions of 00031 * the GPL or the LGPL are applicable instead of those above. If you wish to 00032 * allow use of your version of this file only under the terms of the either 00033 * the GPL or LGPL and not to allow others to use your version of this file 00034 * under the MPL, indicate your decision by deleting the provisions above 00035 * and replace them with the notice and other provisions required by the GPL 00036 * or LGPL. If you do not delete the provisions above, a recipient may use 00037 * your version of this file under the terms of any one of the MPL, the GPL 00038 * or the LGPL. 00039 * ***** END LICENSE BLOCK ***** */ 00040 00041 #ifndef _ARRAYS_H_ 00042 #define _ARRAYS_H_ 00043 00044 //basic array types used for pictures etc 00045 00046 #include <memory> 00047 #include <cstddef> 00048 #include <stdexcept> 00049 #include <iostream> 00050 #include <algorithm> 00051 #include <cstring> 00052 00053 namespace dirac 00054 { 00056 00060 class Range 00061 { 00062 public: 00064 00067 Range(int s, int e): m_fst(s), m_lst(e){} 00068 00070 int First() const {return m_fst;} 00071 00073 int Last() const {return m_lst;} 00074 00075 private: 00076 int m_fst ,m_lst; 00077 }; 00078 00080 //One-Dimensional Array type// 00082 00084 00089 template <class T> class OneDArray 00090 { 00091 public: 00093 00096 OneDArray(); 00097 00099 00102 OneDArray(const int len); 00103 00105 00110 OneDArray(const Range& r); 00111 00113 00116 ~OneDArray() 00117 { 00118 FreePtr(); 00119 } 00120 00122 00125 OneDArray(const OneDArray<T>& cpy); 00126 00128 00131 OneDArray<T>& operator=(const OneDArray<T>& rhs); 00132 00134 void Resize(int l); 00135 00137 T& operator[](const int pos){return m_ptr[pos-m_first];} 00138 00140 const T& operator[](const int pos) const {return m_ptr[pos-m_first];} 00141 00143 int Length() const {return m_length;} 00144 00146 int First() const {return m_first;} 00147 00149 int Last() const {return m_last;} 00150 00151 private: 00152 void Init(const int len); 00153 00154 void Init(const Range& r); 00155 00156 void FreePtr(); 00157 00158 int m_first, m_last; 00159 int m_length; 00160 T* m_ptr; 00161 }; 00162 00163 //public member functions// 00165 00166 template <class T> 00167 OneDArray<T>::OneDArray() 00168 { 00169 Init(0); 00170 } 00171 00172 template <class T> 00173 OneDArray<T>::OneDArray(const int len) 00174 { 00175 Init(len); 00176 } 00177 00178 template <class T> 00179 OneDArray<T>::OneDArray(const Range& r) 00180 { 00181 Init(r); 00182 } 00183 00184 template <class T> 00185 OneDArray<T>::OneDArray(const OneDArray<T>& cpy) 00186 { 00187 m_first = cpy.m_first; 00188 m_last = cpy.m_last; 00189 m_length = m_last - m_first + 1; 00190 00191 if (m_first==0) 00192 Init(m_length); 00193 else 00194 Init(Range(m_first , m_last)); 00195 00196 memcpy( m_ptr , cpy.m_ptr , m_length * sizeof( T ) ); 00197 } 00198 00199 template <class T> 00200 OneDArray<T>& OneDArray<T>::operator=(const OneDArray<T>& rhs) 00201 { 00202 if (&rhs != this) 00203 { 00204 FreePtr(); 00205 m_first = rhs.m_first; 00206 m_last = rhs.m_last; 00207 m_length = rhs.m_length; 00208 00209 if (m_first == 0) 00210 Init(m_length); 00211 else 00212 Init(Range(m_first , m_last)); 00213 00214 memcpy( m_ptr , rhs.m_ptr , m_length * sizeof( T ) ); 00215 00216 } 00217 return *this; 00218 } 00219 00220 template <class T> 00221 void OneDArray<T>::Resize(int l) 00222 { 00223 if (l != m_length) 00224 { 00225 FreePtr(); 00226 Init(l); 00227 } 00228 } 00229 00230 //private member functions// 00232 00233 template <class T> 00234 void OneDArray<T>::Init(const int len) 00235 { 00236 Range r(0 , len-1); 00237 00238 Init(r); 00239 00240 } 00241 00242 template <class T> 00243 void OneDArray<T>::Init(const Range& r) 00244 { 00245 00246 m_first = r.First(); 00247 m_last = r.Last(); 00248 m_length = m_last - m_first + 1; 00249 00250 if ( m_length>0 ) 00251 { 00252 m_ptr = new T[ m_length ]; 00253 } 00254 else 00255 { 00256 m_length = 0; 00257 m_first = 0; 00258 m_last = -1; 00259 m_ptr = NULL; 00260 } 00261 } 00262 00263 template <class T> 00264 void OneDArray<T>::FreePtr() 00265 { 00266 if ( m_length>0 ) 00267 delete[] m_ptr; 00268 } 00269 00270 00272 //Two-Dimensional Array type// 00274 00276 00284 template <class T> class TwoDArray 00285 { 00286 typedef T* element_type; 00287 00288 public: 00289 00291 00294 TwoDArray(){ Init(0,0); } 00295 00297 00300 TwoDArray( const int height , const int width ){Init(height , width);} 00301 00303 00307 TwoDArray( const int height , const int width , T val); 00308 00310 00313 virtual ~TwoDArray(){ 00314 FreeData(); 00315 } 00316 00318 00321 TwoDArray(const TwoDArray<T>& Cpy); 00322 00324 00327 TwoDArray<T>& operator=(const TwoDArray<T>& rhs); 00328 00330 00336 bool CopyContents(TwoDArray<T>& out) const; 00337 00339 00342 void Fill(T val); 00343 00345 void Resize(const int height, const int width); 00346 00348 00352 inline element_type& operator[](const int pos){return m_array_of_rows[pos];} 00353 00355 00359 inline const element_type& operator[](const int pos) const {return m_array_of_rows[pos];} 00360 00362 int LengthX() const { return m_length_x; } 00363 00365 int LengthY() const { return m_length_y; } 00366 00368 int FirstX() const { return m_first_x; } 00369 00371 int FirstY() const { return m_first_y; } 00372 00374 int LastX() const { return m_last_x; } 00375 00377 int LastY() const { return m_last_y; } 00378 00379 private: 00381 void Init(const int height,const int width); 00382 00384 void FreeData(); 00385 00386 int m_first_x; 00387 int m_first_y; 00388 00389 int m_last_x; 00390 int m_last_y; 00391 00392 int m_length_x; 00393 int m_length_y; 00394 00395 element_type* m_array_of_rows; 00396 }; 00397 00398 //public member functions// 00400 00401 template <class T> 00402 TwoDArray<T>::TwoDArray( const int height , const int width , const T val) 00403 { 00404 Init( height , width ); 00405 std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val); 00406 } 00407 00408 template <class T> 00409 TwoDArray<T>::TwoDArray(const TwoDArray<T>& Cpy) 00410 { 00411 m_first_x = Cpy.m_first_x; 00412 m_first_y = Cpy.m_first_y; 00413 m_last_x = Cpy.m_last_x; 00414 m_last_y = Cpy.m_last_y; 00415 00416 m_length_x = m_last_x - m_first_x + 1; 00417 m_length_y = m_last_y - m_first_y + 1; 00418 00419 if (m_first_x == 0 && m_first_y == 0) 00420 Init(m_length_y , m_length_x); 00421 else{ 00422 //based 2D arrays not yet supported 00423 } 00424 00425 memcpy( m_array_of_rows[0] , (Cpy.m_array_of_rows)[0] , m_length_x * m_length_y * sizeof( T ) ); 00426 00427 } 00428 00429 template <class T> 00430 TwoDArray<T>& TwoDArray<T>::operator=(const TwoDArray<T>& rhs) 00431 { 00432 if (&rhs != this) 00433 { 00434 FreeData(); 00435 00436 m_first_x = rhs.m_first_x; 00437 m_first_y = rhs.m_first_y; 00438 00439 m_last_x = rhs.m_last_x; 00440 m_last_y = rhs.m_last_y; 00441 00442 m_length_x = m_last_x - m_first_x + 1; 00443 m_length_y = m_last_y - m_first_y + 1; 00444 00445 if (m_first_x == 0 && m_first_y == 0) 00446 Init(m_length_y , m_length_x); 00447 else 00448 { 00449 //based 2D arrays not yet supported 00450 } 00451 00452 memcpy( m_array_of_rows[0], (rhs.m_array_of_rows)[0], m_length_x * m_length_y * sizeof( T ) ); 00453 00454 } 00455 00456 return *this; 00457 00458 } 00459 00460 template <class T> 00461 bool TwoDArray<T>::CopyContents(TwoDArray<T>& out) const 00462 { 00463 if (&out != this) 00464 { 00465 int rows = std::min (m_length_y, out.m_length_y); 00466 int cols = std::min (m_length_x, out.m_length_x); 00467 for (int j = 0; j < rows; ++j) 00468 { 00469 memcpy( out.m_array_of_rows[j], m_array_of_rows[j], cols * sizeof( T )) ; 00470 for (int i = cols; i <out.m_length_x; ++i) 00471 out.m_array_of_rows[j][i] = out.m_array_of_rows[j][cols-1]; 00472 } 00473 for (int j = rows; j < out.m_length_y; ++j) 00474 { 00475 memcpy( out.m_array_of_rows[j], out.m_array_of_rows[rows-1], out.m_length_x * sizeof( T )) ; 00476 } 00477 } 00478 return true; 00479 } 00480 00481 template <class T> 00482 void TwoDArray<T>::Fill( T val) 00483 { 00484 if (m_length_x && m_length_y) 00485 std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val); 00486 } 00487 00488 template <class T> 00489 void TwoDArray<T>::Resize(const int height, const int width) 00490 { 00491 if (height != m_length_y || width != m_length_x) 00492 { 00493 FreeData(); 00494 Init(height , width); 00495 } 00496 } 00497 00498 //private member functions// 00500 00501 template <class T> 00502 void TwoDArray<T>::Init(const int height , const int width) 00503 { 00504 m_length_x = width; 00505 m_length_y = height; 00506 m_first_x = 0; 00507 m_first_y = 0; 00508 00509 m_last_x = m_length_x-1; 00510 m_last_y = m_length_y-1; 00511 00512 if (m_length_y>0) 00513 { 00514 // allocate the array containing ptrs to all the rows 00515 m_array_of_rows = new element_type[ m_length_y ]; 00516 00517 if ( m_length_x>0 ) 00518 { 00519 // Allocate the whole thing as a single big block 00520 m_array_of_rows[0] = new T[ m_length_x * m_length_y ]; 00521 00522 // Point the pointers 00523 for (int j=1 ; j<m_length_y ; ++j) 00524 m_array_of_rows[j] = m_array_of_rows[0] + j * m_length_x; 00525 } 00526 else 00527 { 00528 m_length_x = 0; 00529 m_first_x = 0; 00530 m_last_x = -1; 00531 } 00532 } 00533 else 00534 { 00535 m_length_x = 0; 00536 m_length_y = 0; 00537 m_first_x = 0; 00538 m_first_y = 0; 00539 m_last_x = -1; 00540 m_last_y = -1; 00541 m_array_of_rows = NULL; 00542 } 00543 } 00544 00545 template <class T> 00546 void TwoDArray<T>::FreeData() 00547 { 00548 if (m_length_y>0) 00549 { 00550 if (m_length_x>0) 00551 { 00552 delete[] m_array_of_rows[0]; 00553 } 00554 00555 m_length_y = m_length_x = 0; 00556 // deallocate the array of rows 00557 delete[] m_array_of_rows; 00558 } 00559 } 00560 00561 // Related functions 00562 00564 template <class T > 00565 std::ostream & operator<< (std::ostream & stream, TwoDArray<T> & array) 00566 { 00567 for (int j=0 ; j<array.LengthY() ; ++j) 00568 { 00569 for (int i=0 ; i<array.LengthX() ; ++i) 00570 { 00571 stream << array[j][i] << " "; 00572 }// i 00573 stream << std::endl; 00574 }// j 00575 00576 return stream; 00577 } 00578 00580 template <class T > 00581 std::istream & operator>> (std::istream & stream, TwoDArray<T> & array) 00582 { 00583 for (int j=0 ; j<array.LengthY() ; ++j) 00584 { 00585 for (int i=0 ; i<array.LengthX() ; ++i) 00586 { 00587 stream >> array[j][i]; 00588 }// i 00589 }// j 00590 00591 return stream; 00592 } 00593 00594 } //namespace dirac 00595 #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.