#ifndef NARRAY2D_HH
#define NARRAY2D_HH
/////////////////////////////////////////////////////////////////////////
//! file="amma/StdType/StdArray/NArray2d.hh"
//! lib=MstdArr
//! userlevel=Normal
//! author="Radek Marik"
//! docentry="Containers.Arrays.2-D Arrays"
//! rcsid="$Id: NArray2d.hh,v 1.11 2000/10/04 12:41:55 ees1cg Exp $"
//! date="06/08/95"

#include <iostream.h>
#include "amma/Index.hh"
#include "amma/IndexR2d.hh"
#include "amma/Array1d.hh"
#include "amma/Array2d.hh"
#include "amma/NArray1d.hh"

class Index2dC;
class IndexRectangleC;

//: A 2 dimensional numerical array

template <class DataC>
class NumArray2dC: public Array2dC<DataC>
{
public:
  NumArray2dC();
  //: Default constructor.
  // Creates an empty array.
  
  NumArray2dC(const Array2dC<DataC> & vv);
  //: Constructor from normal array.
  
  NumArray2dC(const SizeT rdim, const SizeT cdim);
  //: Constructor 
  
  NumArray2dC(const IndexRangeC & rowRange,
	      const IndexRangeC & colRange);
  //: Range constructor.
  
  NumArray2dC(const IndexRange2dC & range);
  //: Range constructor.
  
  NumArray2dC(const IndexRectangleC & rect);
  // Creates 2D array with the range covering indexes in 'rect'.
  
  NumArray2dC(const NumArray2dC<DataC> & vv);
  //: Copy constructor.

  
  NumArray2dC<DataC> Copy() const;
  //: Make a copy.
  
  NumArray2dC<DataC> & SetZero();
  // Sets all value of the array to be zero.
  
  NumArray2dC<DataC> & Set(const DataC & data);
  // Sets all items of the array to be 'data'.
  
  void SetRow(IndexT r, const DataC & data);
  // Sets all items in the row 'r' to be 'data'.
  
  void SetCol(IndexT c, const DataC & data);
  // Sets all items in the column 'c' to be 'data'.
  
  inline Index2dC RangeMin() const;
  // Returns the minimum index of the array.
  
  inline Index2dC RangeMax() const;
  // Returns the maximum index of the array.
  
  inline BooleanT Contains(const Index2dC & i) const;
  // Returns TRUE, if there is an item of the 2D array.
  
  void DebugAddresses() const;
  // Prints addresses.
  
//  friend istream & operator>>(istream & s, NumArray2dC<DataC> & arr);
};


template <class DataC>
ostream & operator<<(ostream & s, const NumArray2dC<DataC> & arr) 
{ return operator<<(s,(const Array2dC<DataC> &) arr); }

template <class DataC>
istream & operator>>(istream & s, NumArray2dC<DataC> & arr)
{ return operator>>(s,(Array2dC<DataC> &) arr); }

#include <iostream.h>
#include "amma/StdStrm.hh"
#include "amma/Index2d.hh"
#include "amma/IndRect.hh"

template <class DataC>
NumArray2dC<DataC>::NumArray2dC()
{}

template <class DataC>
NumArray2dC<DataC>::NumArray2dC(const Array2dC<DataC> & vv)
  : Array2dC<DataC>(vv)
{}

template <class DataC>
NumArray2dC<DataC>::NumArray2dC(const SizeT rdim,
                                const SizeT cdim)
  : Array2dC<DataC>(rdim,cdim)
{}

template <class DataC>
NumArray2dC<DataC>::NumArray2dC(const IndexRangeC & rowRange,
                                const IndexRangeC & colRange)
  : Array2dC< DataC >(rowRange,colRange)
{}

template <class DataC>
NumArray2dC<DataC>::NumArray2dC(const IndexRange2dC & range)
  : Array2dC< DataC >(range.RowRange(),range.ColRange())
{}

template <class DataC>
NumArray2dC<DataC>::NumArray2dC(const IndexRectangleC & rect)
  : Array2dC< DataC >(rect)
{}

//IndexRangeC(rect.Origin().Row(),rect.End().Row())

template <class DataC>
NumArray2dC<DataC>::NumArray2dC(const NumArray2dC<DataC> & vv)
    : Array2dC< DataC >(vv)
{}

template <class DataC>
NumArray2dC<DataC>
NumArray2dC<DataC>::Copy() const
{ return Array2dC<DataC>::Copy(); }

template <class DataC>
NumArray2dC<DataC> &
NumArray2dC<DataC>::SetZero()
{ 
  Fill(0); 
  return *this; 
}

template <class DataC>
NumArray2dC<DataC> &
NumArray2dC<DataC>::Set(const DataC & data) 
{
  Fill(data);
  return *this;
}

template <class DataC>
inline 
Index2dC 
NumArray2dC<DataC>::RangeMin() const
//==================================
{
  return Index2dC(Range1().Min(), Range2().Min());
}

template <class DataC>
inline 
Index2dC 
NumArray2dC<DataC>::RangeMax() const
//==================================
{
  return Index2dC(Range1().Max(), Range2().Max());
}

template <class DataC>
inline
void 
NumArray2dC<DataC>::SetRow(IndexT r, const DataC & data)
//======================================================
{
  IndexRangeC range(Range2());
  for (Index2dC i(r, range.Min()); i.Col() <= range.Max(); i.Col()++)
    (*this)[i] = data;
}

template <class DataC>
inline
void 
NumArray2dC<DataC>::SetCol(IndexT c, const DataC & data)
//======================================================
{
  IndexRangeC range(Range1());
  for (Index2dC i(range.Min(), c); i.Row() <= range.Max(); i.Row()++)
    (*this)[i] = data;
}

template <class DataC>
inline
BooleanT
NumArray2dC<DataC>::Contains(const Index2dC & i) const
//====================================================
{
  return     Range1().Contains(i.Row())
         &&  Range2().Contains(i.Col());
}

template <class DataC>
void 
NumArray2dC<DataC>::DebugAddresses() const
//=======================================
{
  cerrAMMA << "NumArray2dC<DataC>::DebugAddresses() "; 
  Array1dC< NumArray1dC<DataC> >::DebugAddresses();
  FOR_ARRAY1(*this, i)
  {
    cerrAMMA << i << ' ';
    (*this)[i].DebugAddresses();
  }
}

#endif

// IAPS - Image analysis program system.
// End of include file NArray2d.hh