Dirac - A Video Codec

Created by the British Broadcasting Corporation.


arrays.h

Go to the documentation of this file.
00001 /* ***** BEGIN LICENSE BLOCK *****
00002 *
00003 * $Id: arrays.h,v 1.16 2006/06/05 14:52:09 asuraparaju Exp $ $Name: Dirac_0_6_0 $
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 
00052 namespace dirac
00053 {
00054     typedef short ValueType;
00055 
00056     typedef int CalcValueType;
00057 
00059 
00063     class Range
00064     {
00065     public:
00067 
00070         Range(int s, int e): m_fst(s), m_lst(e){}
00071 
00073         const int First() const {return m_fst;}
00074 
00076         const int Last() const {return m_lst;}
00077 
00078     private:
00079         int m_fst ,m_lst;
00080     };
00081 
00083     //One-Dimensional Array type//
00085 
00087 
00092     template <class T> class OneDArray
00093     {
00094     public:
00096 
00099         OneDArray();
00100 
00102 
00105         OneDArray(const int len);
00106 
00108 
00113         OneDArray(const Range& r);
00114 
00116 
00119         ~OneDArray()
00120         {
00121             FreePtr();
00122         }
00123 
00125 
00128         OneDArray(const OneDArray<T>& cpy);
00129 
00131 
00134         OneDArray<T>& operator=(const OneDArray<T>& rhs);    
00135 
00137         void Resize(int l);
00138 
00140         T& operator[](const int pos){return m_ptr[pos-m_first];}
00141 
00143         const T& operator[](const int pos) const {return m_ptr[pos-m_first];}
00144 
00146         int Length() const {return m_length;}
00147 
00149         int First() const {return m_first;}
00150 
00152         int Last() const {return m_last;}
00153 
00154     private:
00155         void Init(const int len);
00156 
00157         void Init(const Range& r);
00158 
00159         void FreePtr();    
00160 
00161         int m_first, m_last;
00162         int m_length;
00163         T* m_ptr;
00164     };
00165 
00166     //public member functions//
00168 
00169     template <class T>
00170     OneDArray<T>::OneDArray()
00171     {
00172         Init(0);
00173     }
00174 
00175     template <class T>
00176     OneDArray<T>::OneDArray(const int len)
00177     {
00178         Init(len);
00179     }
00180 
00181     template <class T>
00182     OneDArray<T>::OneDArray(const Range& r)
00183     {
00184         Init(r);
00185     }
00186 
00187     template <class T>
00188     OneDArray<T>::OneDArray(const OneDArray<T>& cpy)
00189     {
00190         m_first = cpy.m_first;
00191         m_last = cpy.m_last;
00192         m_length = m_last - m_first + 1;
00193 
00194         if (m_first==0)
00195             Init(m_length);
00196         else
00197             Init(Range(m_first , m_last));
00198 
00199         memcpy( m_ptr , cpy.m_ptr , m_length * sizeof( T ) );
00200     }
00201 
00202     template <class T>
00203     OneDArray<T>& OneDArray<T>::operator=(const OneDArray<T>& rhs)
00204     {
00205         if (&rhs != this)
00206         {
00207             FreePtr();
00208             m_first = rhs.m_first;
00209             m_last = rhs.m_last;
00210             m_length = rhs.m_length;
00211 
00212             if (m_first == 0)
00213                 Init(m_length);
00214             else
00215                 Init(Range(m_first , m_last));
00216 
00217             memcpy( m_ptr , rhs.m_ptr , m_length * sizeof( T ) );
00218 
00219         }
00220         return *this;
00221     }
00222 
00223     template <class T> 
00224     void OneDArray<T>::Resize(int l)
00225     {
00226         if (l != m_length)
00227         {
00228             FreePtr();
00229             Init(l);
00230         }
00231     }
00232 
00233     //private member functions//
00235 
00236     template <class T>
00237     void OneDArray<T>::Init(const int len)
00238     {
00239         Range r(0 , len-1);
00240 
00241         Init(r);
00242 
00243     }        
00244 
00245     template <class T>
00246     void OneDArray<T>::Init(const Range& r)
00247     {
00248 
00249         m_first = r.First();
00250         m_last = r.Last();
00251         m_length = m_last - m_first + 1; 
00252 
00253         if ( m_length>0 ) 
00254         {
00255             m_ptr = new T[ m_length ];
00256         }
00257         else 
00258         {
00259             m_length = 0;
00260             m_first = 0;
00261             m_last = -1;
00262         }
00263     }
00264 
00265     template <class T>
00266     void OneDArray<T>::FreePtr()
00267     {
00268         if ( m_length>0 )
00269             delete[] m_ptr;
00270     }
00271 
00272 
00274     //Two-Dimensional Array type//
00276 
00278 
00286     template <class T> class TwoDArray
00287     {
00288         typedef T* element_type;
00289 
00290     public:
00291 
00293 
00296         TwoDArray(){ Init(0,0); }
00297 
00299 
00302         TwoDArray( const int height , const int width ){Init(height , width);}
00303 
00305 
00309         TwoDArray( const int height , const int width , T val);
00310 
00312 
00315         virtual ~TwoDArray(){
00316             FreeData();    
00317         }
00318 
00320 
00323         TwoDArray(const TwoDArray<T>& Cpy);
00324 
00326 
00329         TwoDArray<T>& operator=(const TwoDArray<T>& rhs);
00330 
00332         void Resize(const int height, const int width);    
00333 
00335 
00339         inline element_type& operator[](const int pos){return m_array_of_rows[pos];}
00340 
00342 
00346         inline const element_type& operator[](const int pos) const {return m_array_of_rows[pos];}
00347 
00349         const int LengthX() const { return m_length_x; }
00350 
00352         const int LengthY() const { return m_length_y; }
00353 
00355         const int FirstX() const { return m_first_x; } 
00356 
00358         const int FirstY() const { return m_first_y; } 
00359 
00361         const int LastX() const { return m_last_x; } 
00362 
00364         const int LastY() const { return m_last_y; }
00365 
00366     private:
00368         void Init(const int height,const int width);
00369 
00371         void FreeData();    
00372 
00373         int m_first_x;
00374         int m_first_y;
00375 
00376         int m_last_x;
00377         int m_last_y;
00378 
00379         int m_length_x;
00380         int m_length_y;
00381 
00382         element_type* m_array_of_rows;
00383     };
00384 
00385     //public member functions//
00387 
00388     template <class T>
00389     TwoDArray<T>::TwoDArray( const int height , const int width , const T val)
00390     {
00391         Init( height , width );  
00392         std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val);
00393     }  
00394 
00395     template <class T>
00396     TwoDArray<T>::TwoDArray(const TwoDArray<T>& Cpy)
00397     {
00398         m_first_x = Cpy.m_first_x;
00399         m_first_y = Cpy.m_first_y;        
00400         m_last_x = Cpy.m_last_x;
00401         m_last_y = Cpy.m_last_y;
00402 
00403         m_length_x = m_last_x - m_first_x + 1;
00404         m_length_y = m_last_y - m_first_y + 1;        
00405 
00406         if (m_first_x == 0 && m_first_y == 0)        
00407             Init(m_length_y , m_length_x);
00408         else{
00409                 //based 2D arrays not yet supported    
00410         }
00411 
00412         memcpy( m_array_of_rows[0] , (Cpy.m_array_of_rows)[0] , m_length_x * m_length_y * sizeof( T ) );
00413 
00414     }
00415 
00416     template <class T>
00417     TwoDArray<T>& TwoDArray<T>::operator=(const TwoDArray<T>& rhs)
00418     {
00419         if (&rhs != this)
00420         {
00421             FreeData();
00422 
00423             m_first_x = rhs.m_first_x;
00424             m_first_y = rhs.m_first_y;            
00425 
00426             m_last_x = rhs.m_last_x;
00427             m_last_y = rhs.m_last_y;
00428 
00429             m_length_x = m_last_x - m_first_x + 1;
00430             m_length_y = m_last_y - m_first_y + 1;        
00431 
00432             if (m_first_x == 0 && m_first_y == 0)
00433                 Init(m_length_y , m_length_x);
00434             else
00435             {
00436                     //based 2D arrays not yet supported
00437             }
00438 
00439             memcpy( m_array_of_rows[0], (rhs.m_array_of_rows)[0], m_length_x * m_length_y * sizeof( T ) );
00440 
00441         }
00442 
00443         return *this;
00444 
00445     }
00446 
00447     template <class T>
00448     void TwoDArray<T>::Resize(const int height, const int width)
00449     {
00450         if (height != m_length_y || width != m_length_x)
00451         {
00452             FreeData();
00453             Init(height , width);
00454         }
00455     }
00456 
00457     //private member functions//
00459 
00460     template <class T>
00461     void TwoDArray<T>::Init(const int height , const int width)
00462     {
00463         m_length_x = width; 
00464         m_length_y = height;
00465         m_first_x = 0;
00466         m_first_y = 0;
00467 
00468         m_last_x = m_length_x-1;
00469         m_last_y = m_length_y-1;
00470 
00471         if (m_length_y>0)
00472         {
00473             // allocate the array containing ptrs to all the rows
00474             m_array_of_rows = new element_type[ m_length_y ];
00475 
00476             if ( m_length_x>0 )
00477             {
00478                 // Allocate the whole thing as a single big block
00479                 m_array_of_rows[0] = new T[ m_length_x * m_length_y ];
00480 
00481                 // Point the pointers
00482                 for (int j=1 ; j<m_length_y ; ++j)
00483                     m_array_of_rows[j] = m_array_of_rows[0] + j * m_length_x;
00484             }
00485             else
00486             {
00487                 m_length_x = 0;
00488                 m_first_x = 0;
00489                 m_last_x = -1;
00490             }
00491         }
00492         else 
00493         {
00494             m_length_x = 0;
00495             m_length_y = 0;
00496             m_first_x = 0;
00497             m_first_y = 0;
00498             m_last_x = -1;
00499             m_last_y = -1;
00500         }
00501     }
00502 
00503     template <class T>
00504     void TwoDArray<T>::FreeData()
00505     {
00506         if (m_length_y>0)
00507         {
00508             if (m_length_x>0) 
00509             {
00510                 delete[] m_array_of_rows[0];
00511             }
00512 
00513             m_length_y = m_length_x = 0;
00514             // deallocate the array of rows
00515             delete[] m_array_of_rows;
00516         }    
00517     }
00518 
00519     // Related functions
00520 
00522     template <class T >
00523     std::ostream & operator<< (std::ostream & stream, TwoDArray<T> & array)
00524     {
00525         for (int j=0 ; j<array.LengthY() ; ++j)
00526         {
00527             for (int i=0 ; i<array.LengthX() ; ++i)
00528             {
00529                 stream << array[j][i] << " ";
00530             }// i
00531             stream << std::endl;
00532         }// j
00533 
00534         return stream;
00535     }
00536 
00538     template <class T >
00539     std::istream & operator>> (std::istream & stream, TwoDArray<T> & array)
00540     {
00541         for (int j=0 ; j<array.LengthY() ; ++j)
00542         {
00543             for (int i=0 ; i<array.LengthX() ; ++i)
00544             {
00545                 stream >> array[j][i];
00546             }// i
00547         }// j
00548 
00549         return stream;
00550     }
00551 
00552 } //namespace dirac
00553 #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.