Array2D.hh

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/
#ifndef __Array2D_hh__
#define __Array2D_hh__

#include <bias_config.h>

#include <Base/Debug/Exception.hh>

namespace BIAS {
  
  template <class T> class Array2D;

  template <class T> 
  std::ostream &operator<<(std::ostream& os, const Array2D<T> &arg);

  /** @class Array2D
      @brief generic two dimensional rectangular array holding arbitrary data
      types
            @test tested with TestArray2D.cpp
      The syntax of the access functions is kept similar to the stl:: classes
      
      @author woelk 09/2007 (c) www.vision-n.de */
  template <class T>  
  class  Array2D
  {
  public:
    Array2D();

    Array2D(const unsigned nrows, const unsigned ncols);

    // copy constructor
    Array2D(const Array2D<T>& m);

    ~Array2D();

    /// copy operator
    Array2D<T>& operator=(const Array2D<T>& m);

    /// frees the memory
    void clear();

    /// preserves the content
    void resize(const unsigned  nrows, const unsigned ncols);

    bool empty() const 
    { return (Data_==0); }

    /// fills the array with val
    void fill(const T& val);

    unsigned ncols() const { return Ncols_; }

    unsigned nrows() const { return Nrows_; }

    unsigned size() const { return Nrows_ * Ncols_; }

    /// checked element access
    T&       operator()(const unsigned row, const unsigned col);
    const T& operator()(const unsigned row, const unsigned col) const;

    /// unchecked element access
    T* operator[](const unsigned row) { return &(Data_[row*Ncols_]); }
    const T* operator[](const unsigned row) const 
    { return &(Data_[row*Ncols_]); }

    class const_iterator;

    /// for iterator access
    /// todo: derive from std::iterator class(es)
    class iterator
    {
    public:
      inline iterator() : Val_(0) {}
      inline iterator(const iterator& it) : Val_(it.Val_) {}
      inline ~iterator() {}
      inline T& operator*() { return *Val_; }
      inline T* operator->() { return Val_; }
      inline iterator operator++(int) { Val_++; return *this; }
      inline bool operator==(const iterator& it) { return (Val_ == it.Val_); }
      inline bool operator!=(const iterator& it) { return (Val_ != it.Val_); }
      inline iterator& operator=(const iterator& it) 
      { Val_ = it.Val_; return *this; }

      friend class Array2D;
      friend class const_iterator;
    private:
      T *Val_;
      inline iterator(T *t) : Val_(t) {}
    };

    /// for const_iterator access
    /// todo: derive from std::iterator class(es)
    class  const_iterator
    {
    public:
      inline const_iterator() : Val_(0) {}
      inline const_iterator(const iterator& it) : Val_(it.Val_) {}
      inline const_iterator(const const_iterator& it) : Val_(it.Val_) {}
      inline ~const_iterator() {}
      inline const T& operator*() { return *Val_; }
      inline const T* operator->() { return Val_; }
      inline const_iterator operator++(int) { Val_++; return *this; }
      inline bool operator==(const const_iterator& it) 
      { return (Val_ == it.Val_); }
      inline bool operator!=(const const_iterator& it) 
      { return (Val_ != it.Val_); }
      inline const_iterator& operator=(const const_iterator& it) 
      { Val_ = it.Val_; return *this; }

      friend class Array2D;
    private:
      const T *Val_;
      inline const_iterator(T *t) : Val_(t) {}
    };

    const_iterator begin() const { return const_iterator(Data_); }
    const_iterator end() const 
    { return const_iterator(Data_+(Nrows_*Ncols_)); }
    iterator begin() { return iterator(Data_); }
    iterator end() { return iterator(Data_+(Nrows_*Ncols_)); }
    
  private:
    T* Data_;
    unsigned Nrows_, Ncols_;
  };

  /////////////////////////////////////////////////////////////////
  // implementation
  /////////////////////////////////////////////////////////////////

  template <class T>
  Array2D<T>::Array2D()
    : Data_(0), Nrows_ (0), Ncols_ (0)
  {}


  template <class T>
  Array2D<T>::Array2D(const unsigned nrows, const unsigned ncols)
    : Data_(new T[nrows * ncols]), Nrows_ (nrows), Ncols_ (ncols)
  {
    if (nrows == 0 || ncols == 0)
      BEXCEPTION("invalid size in Arra2D "<<nrows<<"x"<<ncols);
  }


  template <class T>
  Array2D<T>::Array2D(const Array2D<T>& m)
    : Data_(0), Nrows_ (0), Ncols_(0)
  { *this = m; }


  template <class T>
  Array2D<T>::~Array2D()
  { clear(); }


  template<class T>
  Array2D<T>& Array2D<T>::operator=(const Array2D<T>& m)
  {
    // if (m.Data_ == Data_) {
//       BEXCEPTION("self assignement");
//     }
    // this indirection is necessary to be able to cope with self assignement
    const int size = m.Ncols_*m.Nrows_;
    T *tmp = new T[size];
    // do not use memcopy here: memcopy cannot cope with complex objects
    // allocating memory themselve
    for (int i=0; i<size; i++){ tmp[i] = m.Data_[i]; }
    if (!empty()) { clear(); }
    Data_ = tmp;
    Nrows_ = m.Nrows_;
    Ncols_ = m.Ncols_;
    return *this;
  }


  template<class T>
  void Array2D<T>::clear()
  { if (Data_){ delete[] Data_; Data_ = 0; Ncols_ = Nrows_ = 0; } }


  template<class T>
  void Array2D<T>::resize(const unsigned nrows, const unsigned ncols)
  { 
    if (nrows==Nrows_ && ncols==Ncols_) return;
    T *tmp = new T[nrows*ncols];
    if (Data_){
      // preserve existing data
      const unsigned nr=Nrows_, nc=Ncols_;
      unsigned r, c, tmp_offs, old_offs;
      for (r=0; r<nr; r++){
        tmp_offs = r*ncols;
        old_offs = r*nc;
        for (c=0; c<nc; c++){
          tmp[tmp_offs+c] = Data_[old_offs+c];
        }
      }
      delete[] Data_;
    } 
    Data_ = tmp;
    Nrows_ = nrows;
    Ncols_ = ncols;
  }

  
  template<class T>
  void Array2D<T>::fill(const T& val)
  {
    const unsigned nr=Nrows_, nc=Ncols_;
    unsigned r, c, offs;
    for (r=0; r<nr; r++){
      offs = r*nc;
      for (c=0; c<nc; c++){
        Data_[offs+c] = val;
      }
    }
  }
  

  template<class T>
  T& Array2D<T>::operator()(const unsigned row, const unsigned col)
  {
    if (row >= Nrows_ || col >= Ncols_) 
      BEXCEPTION("index out of bounds: array2D size = "<<Ncols_<<"x"<<Nrows_
                 <<"  and index access at ["<<row<<"]["<<col<<"]");
    return Data_[row*Ncols_ + col];
  }


  template<class T>
  const T& Array2D<T>::operator()(const unsigned row, const unsigned col) const
  {
    if (row >= Nrows_ || col >= Ncols_) 
      BEXCEPTION("index out of bounds: array2D size = "<<Ncols_<<"x"<<Nrows_
                 <<"  and index access at ["<<row<<"]["<<col<<"]");
    return Data_[row*Ncols_ + col];
  }

  template <class T> 
  std::ostream &operator<<(std::ostream& os, const Array2D<T> &arg)
  {
    os << arg.nrows() << " " << arg.ncols() << std::endl;
    for (unsigned r=0; r<arg.nrows(); r++){
      for (unsigned c=0; c<arg.ncols(); c++){
        os << arg(r,c) << "\t";
      }
      os << std::endl;
    }
    return os;
  }



} // namespace

#endif