image.h

Go to the documentation of this file.

/* -*- mode: c++; c-basic-offset:3 -*-
 *
 * Copyright (c), GREYC.
 * All rights reserved
 *
 * You may use this file under the terms of the BSD license as follows:
 *
 * "Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *   * Neither the name of the GREYC, nor the name of its
 *     contributors may be used to endorse or promote products
 *     derived from this software without specific prior written
 *     permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 *
 * 
 * For more information, refer to:
 * https://clouard.users.greyc.fr/Pandore
 */

#ifndef __PIMAGEH__
#define __PIMAGEH__

namespace pandore {

class Border2DIterator {
   private:
      Dimension2d _size;
      int _top;
      int _left;
      int _right;
      int _bottom;
      Point2d *_points;
      int _length;
      int _index;

   public:
      Border2DIterator( const Dimension2d size, int c1, int c2, int c3, int c4 ): _size(size), _top(c1), _left(c2), _right(c3), _bottom(c4) {
         _length = size.w * _top
            + size.w * _bottom
            + size.h * _left
            + size.h * _right
            - 2 * (_top + _bottom);
         _points = new Point2d[_length];
         _index = 0;

         Point2d p;
         // top.
         for (p.y = 0; p.y < _top; p.y++) {
            for (p.x = 0; p.x < _size.w; p.x++) {
               _points[_index++] = p;
            }
         }

         // bottom.
         for (p.y = _size.h - _bottom; p.y < _size.h; p.y++) {
            for (p.x = 0; p.x < _size.w; p.x++) {
               _points[_index++] = p;
            }
         }

         // Left
         for (p.x = 0; p.x < _left; p.x++) {
            for (p.y = _top; p.y < _size.h - _bottom; p.y++) {
               _points[_index++] = p;
            }
         }

         // Right
         for (p.x = _size.w - _right; p.x < _size.w; p.x++) {
            for (p.y = _top; p.y < _size.h - _bottom; p.y++) {
               _points[_index++] = p;
            }
         }
         _index = 0;
      }
      bool hasNext() {
         return _index < _length;
      }
      Point2d next() {
         return _points[_index++];
      }
};

class Border3DIterator {
   private:
      Dimension3d _size;
      int _top;
      int _left;
      int _right;
      int _bottom;
      int _front;
      int _back;
      Point3d *_points;
      int _length;
      int _index;

   public:
      Border3DIterator( const Dimension3d size, int c1, int c2, int c3, int c4, int c5, int c6 ): _size(size), _top(c1), _left(c2), _right(c3), _bottom(c4),
_front(c5), _back(c6) {
         _length  = (_front + _back) * (_size.h * _size.w) 
            + (_size.d - _top - _back) * (_top * _size.h + _bottom * _size.h + _left * (_size.w - _top - _bottom) + _right * (_size.w - _top - _bottom)) ;
         _points = new Point3d[_length];
         _index = 0;

         Point3d p;
         // Front
         for (p.z = 0; p.z < _front; p.z++) {
            for (p.y = 0; p.y < _size.h; p.y++) {
               for (p.x = 0; p.x < _size.w; p.x++) {
                  _points[_index++] = p;
               }
            }
         }

         for (p.z = _front; p.z < _size.d - _back; p.z++) {
            // top
            for (p.y = 0; p.y < _top; p.y++) {
               for (p.x = 0; p.x < _size.w; p.x++) {
                  _points[_index++] = p;
               }
            }
            // bottom.
            for (p.y = _size.h- _bottom; p.y < _size.h; p.y++) {
               for (p.x = 0; p.x < _size.w; p.x++) {
                  _points[_index++] = p;
               }
            }
            // Left
            for (p.x = 0; p.x < _left; p.x++) {
               for (p.y = _top; p.y < _size.h - _bottom; p.y++) {
                  _points[_index++] = p;
               }
            }
            // Right
            for (p.x = _size.w - _right; p.x < _size.w; p.x++) {
               for (p.y = _top; p.y < _size.h - _bottom; p.y++) {
                  _points[_index++] = p;
               }
            }
         }

         // Back
         for (p.z = _size.d - _back; p.z < _size.d; p.z++) {
            for (p.y = 0; p.y < _size.h; p.y++) {
               for (p.x = 0; p.x < _size.w; p.x++) {
                  _points[_index++] = p;
               }
            }
         }
         _index = 0;

      }
      bool hasNext() {
         return _index < _length - 1;
      }
      Point3d next() {
         return _points[_index++];
      }
};


template< typename T > 
class Imx2d;
   
   template< typename T > 
   class Imx3d: public Pobject {
      protected:
         class Band1d {
            public:
               // 1D data accessors.
            explicit Band1d( const Imx3d<T> * const /* image*/ , T *offset ) : _offset(offset) {}
               T &operator[]( Long x ) { return _offset[x]; }
               const T &operator[]( Long x ) const { return _offset[x]; }
               T &operator[]( const Point1d &p ) { return _offset[p.x]; }
               const T & operator[]( const Point1d &p ) const { return _offset[p.x]; }
            private:
               T *_offset;
         };
         
         class Band2d {
            public:
               // 2D data accessors.
               explicit Band2d( const Imx3d<T> * const image, T *offset ) : _image(image), _offset(offset) {}
               explicit Band2d(): _image(0), _offset(0) {};
               void New( const Imx3d<T> * const image, T *offset ) { _image = image; _offset=offset; }
               
               Band1d operator[]( Long y ) { return Band1d(_image, &_offset[_image->ncol*y]); }
               const Band1d operator[]( Long y ) const { return Band1d(_image, &_offset[_image->ncol * y]); }
               T &operator[]( const Point2d &p ) { return _offset[_image->ncol * p.y + p.x]; }
               const T & operator[]( const Point2d &p ) const { return _offset[_image->ncol * p.y + p.x]; }
//             T * &operator( )( ) { return &_data[_offset]; } 
               Band2d& operator=( const Imx2d<T> &ims ) {
                  if (_image->Bands() != ims.Bands( )
                      || _image->Depth() != ims.Depth() 
                      || _image->Height() != ims.Height()
                      || _image->Width() != ims.Width()) {
                    std::cerr << "Error: incomptabiles images for operator: 2D image = 3D image[i]" << std::endl;
                  } else {
                     T *ps = ims.Vector();
                     T *pe = ps + ims.Bands() * ims.nrow * ims.ncol;
                     T *pd = _offset;
                     for (; ps<pe; ) {
                        *(pd++) = (T)*(ps++);
                     }
                  }
                  return *this;
               }
               Band2d& operator=( const T val ) {
                  T *pd = _offset;
                  T *pe = pd + _image->nbands * _image->nrow * _image->ncol;
                  for (; pd < pe; ) {
                     *(pd++) = val;
                  }
                  return *this;
               }
            private:
               const Imx3d<T> *_image;
               T *_offset;
         };

         class Band3d {
            public:
               explicit Band3d( const Imx3d<T> * const image, T *offset ) : _image(image), _offset(offset) {}
               // 3D data accessors.
               Band2d operator[]( Long z ) { return Band2d(_image, &_offset[_image->matrixSize * z]); }
               explicit Band3d(): _image(0), _offset(0) {};
               void New( const Imx3d<T> * const image, T *offset ) { _image = image; _offset = offset; }

               const Band2d operator[]( Long z ) const { return Band2d(_image, &_offset[_image->matrixSize * z]); }
               T &operator[]( const Point3d &p ) { return _offset[_image->matrixSize * p.z + _image->ncol * p.y + p.x]; }
               const T & operator[]( const Point3d &p ) const { return _offset[_image->matrixSize * p.z + _image->ncol * p.y + p.x]; }
               T &operator()( const Point3d &p ) { return _offset[_image->matrixSize * p.z + _image->ncol * p.y + p.x]; }
               const T & operator()( const Point3d &p ) const { return _offset[_image->matrixSize * p.z + _image->ncol * p.y + p.x]; }
//             T * &operator( )( ) { return &_data[_offset]; }
            private:
               const Imx3d<T> *_image;
               T *_offset;
         };

      protected:
         T *_data; 
         bool _isDataOwner;

         Long nbands; 
         Long ncol;
         Long nrow;
         Long ndep;
         Long matrixSize;         
         Long volumeSize;

      private:
         PColorSpace colorspace;

      public:
         typedef T ValueType;

         Typobj Type( ) const { return ( Typobj )Po_type< Imx3d< T > >::type; }

         std::string Name( ) const { return TypeName< Imx3d < T > >::Name( ); }

         Long Width( ) const { return ncol; }

         Long Height( ) const { return nrow; }

         Long Depth( ) const { return ndep; }

         Long Bands( ) const { return nbands; }

         Dimension3d Size( ) const {
            return Dimension3d(ndep, nrow, ncol);
         }

         Ulong VectorSize( ) const {
            return (Ulong)volumeSize;
         }

         PobjectProps Props( ) const {
            return PobjectProps(nbands, ncol, nrow, ndep, colorspace, 0, ndep * ncol * nrow);
         }

         Imx3d( ): Pobject( ), _data(0), _isDataOwner(false), nbands(0), ncol(0), nrow(0), ndep(0), matrixSize(0), volumeSize(0), colorspace(RGB) {
         }

         Imx3d( Long b, Long d, Long h, Long w, T *data = 0, bool isOwner = false ): Pobject (), _data(0), _isDataOwner(isOwner), nbands(0), ncol(0), nrow(0), ndep(0), matrixSize(0), volumeSize(0), colorspace( RGB ) {
            New(b, d, h, w, data);
         }

         Imx3d( Long b, const Dimension3d &d, T *data = 0, bool isOwner = false ): Pobject ( ), _data(0), _isDataOwner(isOwner), nbands(0), ncol(0), nrow(0), ndep(0), matrixSize(0), volumeSize(0), colorspace(RGB) {
            New(b, d. d, d.h, d.w, data);
         }
         
         Imx3d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Pobject ( ), _data(0), _isDataOwner(isOwner), nbands(0), ncol(0), nrow(0), ndep(0), matrixSize(0), volumeSize(0) {
            New(p, data);
         }

          Imx3d( const Imx3d  &ims ): Pobject(), _data(0), _isDataOwner(false), nbands(0), ncol(0), nrow(0), ndep(0) {
             New(ims.Props());
             *this = ims;
          }
      
          ~Imx3d( ) {
             Delete();
          }

         void New( Long b, Long d, Long h, Long w, T *data = 0, bool isOwner = false ) {
            Long size = b * w * h * d;
            if (size <= 0) {
               throw std::runtime_error("Memory allocation error: block too big.");
            }
            if (data != 0 || (nbands * ncol * nrow * ndep != size)) {
               Delete();
               
               if (data == 0) {
                  _isDataOwner = true;
                  _data = new T[size];
               } else {
                  _isDataOwner = isOwner;
                  _data = data;
               }
            }
            ndep = d;
            nrow = h;
            ncol = w;
            nbands = b;
            matrixSize = ncol * nrow;

            volumeSize = matrixSize * ndep;
         }
         
         void New( Long b, const Dimension3d &d, T *data = 0) {
            New(b, d.d, d.h, d.w, data);
         }

         virtual void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) {
            New(p.nbands, p.ndep, p.nrow, p.ncol, data, isOwner);
            colorspace = p.colorspace;
         }
      
         void Delete( ) {
            if (_isDataOwner) {
               delete[] _data;
            }
            _data = 0;
            nbands = ndep = nrow = ncol = matrixSize = volumeSize = 0L;
         }
   
         virtual Pobject* Clone( ) const {
            Imx3d< T > *tmp = new Imx3d< T > (nbands, ndep, nrow, ncol);
            *tmp = *this;
      
            return tmp;
         }
   
         Imx3d< T > &operator=( const T val ) {
            T *bp = Vector();
            T *ep = bp + (nbands * ndep * nrow * ncol);
      
            for (; bp < ep; *(bp++) = val) ;
      
            return *this;
         }
   
         template< typename U >
         Imx3d< T > &operator=( const Imx3d< U > &src ) {
            if (Bands() != src.Bands( ) || Depth() != src.Depth()  ||
                Height() != src.Height() || Width() != src.Width()) {
               Delete();
               New(src.Bands(), src.Depth(), src.Height(), src.Width());
            }
            T *pd = Vector();
            U *ps = src.Vector();
            U *pe = ps + nbands * ndep * nrow * ncol;
            
            for (; ps < pe; ) {
               *(pd++) = (T)*(ps++);
            }
            return *this;
         }

         Imx3d< T > &operator=( const Imx3d< T > &src ) {
            if (Bands() != src.Bands( )
                || Depth() != src.Depth() 
                || Height() != src.Height()
                || Width() != src.Width()) {
               Delete();
               New(src.Bands(), src.Depth(), src.Height(), src.Width());
            }
            memcpy(Vector(), src.Vector(), nbands * ndep * nrow * ncol * sizeof(T));
            return *this;
         }
   
         T* Vector( Long band = 0 ) const {
            return &_data[volumeSize * band];
         }

         Band3d operator[]( Long band ) {
            return Band3d(this, &_data[volumeSize * band]);
         }
      
         const Band3d operator[]( Long band ) const {
            return Band3d(this, &_data[volumeSize * band]);
         }

         T &operator()( Long b, Long z, Long y, Long x ) {
            return _data[volumeSize * b + matrixSize * z + ncol * y + x];
         }

         const T &operator()( Long b, Long z, Long y, Long x ) const {
            return _data[volumeSize * b + matrixSize * z + ncol * y + x];
         }
         
         
         T &operator()( Long b, Point3d &p ) {
            return _data[volumeSize * b + matrixSize * p.z + ncol * p.y + p.x];
         }
         
         const T &operator()( Long b, Point3d &p ) const {
            return _data[volumeSize * b + matrixSize * p.z + ncol * p.y + p.x];
         }
         
         virtual Errc LoadAttributes( FILE *file ) {
            Long attr[4];
      
            if (this->Fdecode((void*)attr, sizeof(*attr), 4, file) < 4) {
               return FAILURE;
            }
            New(attr[0], attr[1], attr[2], attr[3]);
            return SUCCESS;
         }
   
         virtual Errc SaveAttributes( FILE *file ) const {
            Long attr[4];

            attr[0] = nbands;
            attr[1] = ndep;
            attr[2] = nrow;
            attr[3] = ncol;
            if (this->Fencode((void*)attr, sizeof(*attr), 4, file) < 4) {
               return FAILURE;
            }
            return SUCCESS;
         }

         virtual Errc LoadData( FILE *file ) {
            size_t x = volumeSize;
            // Problem : Visual C++ 2005 cannot call the fread function to read from a buffer
            // that is larger than 64 MB in.
            // See http://support.microsoft.com/default.aspx?scid=kb;en-us;899149

#ifdef _WIN32
            if (x * sizeof(T) < (size_t)67076095) {
#endif
               size_t a;
               for (int b = 0; b < nbands; b++) {
                  if ((a = this->Fdecode((void*)Vector(b), sizeof(T), x, file)) < x) {
                     return FAILURE;
                  }
               }
#ifdef _WIN32
            } else {
               x = matrixSize;
               for (int b = 0; b < nbands; b++) {
                  T *data = Vector(b);
                  for (int z = 0; z < ndep; z++) {
                     if (this->Fdecode((void*)data, sizeof(T), x, file) < x) {
                        return FAILURE;
                     }
                     data += x;
                  }
               }
            }
#endif      
            return SUCCESS;
         }

         virtual Errc SaveData( FILE *file ) const {
            size_t x = volumeSize;
            // Problem : Visual C++ 2005 cannot call the fwrite function to
            // write to a buffer that is larger than 64 MB in. 
            // See: http://support.microsoft.com/default.aspx?scid=kb;en-us;899149
#ifdef _WIN32
            if (x * sizeof(T) < (size_t)67076095) {
#endif
               for (int b = 0; b < nbands; b++) {
                  if (this->Fencode((void*)Vector(b), sizeof(T), x, file) < x) {
                     return FAILURE;
                  }
               }
#ifdef _WIN32
            } else {
               x = matrixSize;
               for (int b = 0; b < nbands; b++) {
                  T *data = Vector(b);
                  for (int z = 0; z < ndep; z++) {
                     if (this->Fencode((void*)data, sizeof(T), x, file) < x) {
                        return FAILURE;
                     }
                     data += x;
                  }
               }
            }
#endif
            return SUCCESS;
         }

         virtual Pobject* Mask( const Pobject* mask ) {
            if ((!mask)
                || (mask->Type() != Po_Reg3d)
                || (reinterpret_cast<const Imx3d<Long>*>(mask)->Size() != Size())) {
               std::cerr << "Warning: bad mask format... ignored" << std::endl;
               return this;
            }
            Imx3d< T > *objd = (Imx3d< T >*)Clone();
            const Imx3d<Long> *m = reinterpret_cast<const Imx3d<Long>*>(mask);
            for (int b = 0; b < nbands; b++) {
               Ulong *pm = (Ulong*)m->Vector(0);
               T *pp = objd->Vector(b);
               T *pq = Vector(b);
               for (int i = 0; i < volumeSize; i++, pq++, pm++, pp++) {
                  *pp = (*pm == 0) ? 0 : *pq;
               }
            }
            return objd;
         }
         
         virtual Pobject* UnMask( const Pobject* mask, const Pobject* reference ) {
            if ((!mask)
                || (mask->Type() != Po_Reg3d)
                || (reinterpret_cast<const Imx3d<Long>*>(mask)->Size() != Size())
                || (reference->Type() != Type())
                || (reinterpret_cast<const Imx3d<T>*>(reference)->Size() != Size())) {
               std::cerr << "Warning: bad unmask format... ignored" << std::endl;
               return this;
            }

            
            const Imx3d< T > *objs = reinterpret_cast<const Imx3d< T >*>(reference);
            Imx3d< T > *objd = (Imx3d< T >*)Clone();
            const Imx3d<Long> *m = reinterpret_cast<const Imx3d<Long>*>(mask);
            for (int b = 0; b < nbands; b++) {
               Ulong *pm = (Ulong*)m->Vector(0);
               T *pp = objd->Vector(b);
               T *pq = Vector(b);
               T *ps = objs->Vector(b);
         
               for (int i = 0; i < volumeSize; i++, pp++, pq++, pm++, ps++) {
                  *pp = (*pm == 0) ? *ps : *pq;
               }
            }
            return objd;
         }
   
         PColorSpace ColorSpace( ) const { return colorspace; }

         PColorSpace ColorSpace( PColorSpace e ) { return colorspace=e; }

         bool Hold( Long z, Long y, Long x ) const {
            return (z>=0) && (z < ndep) && (y >= 0) && (y < nrow) && (x >= 0) && (x < ncol);
         }

         bool Hold( const Point3d &pt ) const {
            return (pt.z >= 0) && (pt.z < ndep) && (pt.y >= 0) && (pt.y < nrow) && (pt.x >= 0) && (pt.x < ncol);
         }

         Errc Frame( ValueType val, Long d, Long h, Long l ) {
            if ((d < 0) || (h < 0) || (l < 0)) {
               return FAILURE;
            }
            for (int b = 0; b < nbands; b++) {
               for (int z = 0; z < ndep; z++) {
                  for (int y = 0; y < nrow; y++) {
                     for (int x = 0; x < l; x++) {
                        operator()(b, z, y, x) = (T)val;
                        operator()(b, z, y, ncol - 1 - x) = (T)val;
                     }
                  }
               }
               for (int z = 0; z < ndep; z++) {
                  for (int y = 0; y < h; y++) {
                     for (int x = l; x < ncol - l; x++) {
                        operator()(b, z, y, x) = (T)val;
                        operator()(b, z, nrow - 1 - y, x) = (T)val;
                     }
                  }
               }
               for (int z = 0; z < d; z++) {
                  for (int y = h; y < nrow - h; y++) {
                     for (int x = l; x < ncol - l; x++) {
                        operator()(b, z, y, x) = (T)val;
                        operator()(b, ndep - 1 - z , y, x) = (T)val;
                     }
                  }
               }
            }
            return SUCCESS;
         }

         Errc Frame( ValueType v, Long d ) {
            return Frame(v, d, d, d);
         }

         template < typename U>
         Errc Frame( const Imx3d < U> &ims, Long d ) {
            return Frame(ims, d, d, d);
         }

         template < typename U >
         Errc Frame( const Imx3d < U > &ims, Long d, Long h, Long l ) {
            if (l == -1) {
               l = h = d;
            }
            if ((d < 0) || (h < 0) || (l < 0)) {
               return FAILURE;
            }
            for ( int b = 0; b < nbands; b++ ) {
               for (int i = 0; i < ndep; i++) {
                  for (int j = 0; j < nrow; j++) {
                     for (int k = 0; k < l; k++) {
                        operator()(b, i, j, k) = ( T )ims(b, i, j, k);
                        operator()(b, i, j, ncol - 1 - k) = ( T )ims(b, i, j, ncol - 1 - k);
                     }
                  }
               }
               for (int i = 0; i < ndep; i++) {
                  for (int j = 0; j < h; j++) {
                     for (int k = l; k < ncol - l; k++) {
                        operator()(b, i, j, k) = ( T )ims(b, i, j , k);
                        operator()(b, i, nrow - 1 - j, k) = ( T )ims(b, i, nrow - 1 - j, k);
                     }
                  }
               }
               for (int i = 0; i < d; i++) {
                  for (int j = h; j < nrow - h; j++) {
                     for (int k = l; k<ncol-l; k++) {
                        operator()(b, i, j, k) = ( T )ims(b, i, j, k);
                        operator()(b, ndep - 1 - i, j, k) = ( T )ims(b, ndep - 1 - i, j, k);
                     }
                  }
               }
            }
            return SUCCESS;
         }

         Border3DIterator *getBorderIterator( int c1, int c2, int c3, int c4, int c5, int c6 ) const {
            return new Border3DIterator(Size(), c1, c2, c3, c4, c5, c6);
         }
   };
   

   template< typename T > 
   class Imx2d: public Imx3d < T > {
      protected:
         using Imx3d < T>::_data;
         using Imx3d < T>::ncol;
         using Imx3d < T>::nrow;
         using Imx3d < T>::nbands;
         using Imx3d < T>::matrixSize;
         using Imx3d < T>::ColorSpace;

      public:
         typedef T ValueType;

         Typobj Type( ) const { return ( Typobj )Po_type< Imx2d < T > >::type; }

         std::string Name( ) const { return TypeName< Imx2d < T > >::Name( ); }

         Dimension2d Size( ) const{ return Dimension2d(nrow, ncol); }

         Imx2d( ): Imx3d < T>( ) { }

      Imx2d( Long b, Long h, Long w, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(b, h, w , data, isOwner); }

         Imx2d( Long b, const Dimension2d &d, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(b, d.h, d.w, data, isOwner); }

         Imx2d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(p, data, isOwner); }

         void New( Long b, Long h, Long w, T *data = 0, bool isOwner = false ) { Imx3d < T>::New(b, 1, h, w, data, isOwner); }

         void New( Long b, const Dimension2d &d, T *data = 0, bool isOwner = false ) {
            New(b, d.h, d.w, data, isOwner);
         }

         void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) {
            New(p.nbands, p.nrow, p.ncol, data, isOwner);
            ColorSpace(p.colorspace);
         }

         Pobject* Clone( ) const {
            Imx2d < T > *tmp = new Imx2d < T >(nbands, nrow, ncol);
            *tmp = *this;
            return tmp;
         }

         /*   
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Imx2d < T > &operator=( const T val ) {
            Imx3d < T>::operator=(val);
            return *this;
         }

         template< typename U >
         Imx2d < T > &operator=( const Imx2d < U > &src ) {
            Imx3d < T>::operator=(src);
            return *this;
         }
 
         Imx2d < T > &operator=( const Imx2d < T > &src ) {
            Imx3d < T>::operator=(src);
            return *this;
         }

         T* Vector( Long band = 0 ) const {
            return &_data[matrixSize * band];
         }

         typename Imx3d < T>::Band2d operator[]( Long band ) { return typename Imx3d < T>::Band2d(this, &_data[matrixSize * band]); } 

         const typename Imx3d < T>::Band2d operator[]( Long band ) const { return typename Imx3d < T>::Band2d(this, &_data[matrixSize * band]); } 

         T &operator()( Long b, Long y, Long x ) { return _data[matrixSize * b + ncol * y + x]; }

         const T &operator()( Long b, Long y, Long x ) const { return _data[matrixSize * b + ncol * y + x]; }

         const T &operator()( Long b, Point2d &p ) const { return _data[matrixSize * b + ncol * p.y + p.x]; }

         T &operator()( Long b, Point2d &p ) { return _data[matrixSize * b + ncol * p.y + p.x]; }

         Errc LoadAttributes( FILE *file ) {
            Long attr[3];
      
            if (this->Fdecode((void*)attr, sizeof(*attr), 3, file) < 3) {
               return FAILURE;
            }
            New(attr[0], attr[1], attr[2]);
            return SUCCESS;
         }
   
         Errc SaveAttributes( FILE *file ) const {
            Long attr[3];

            attr[0] = nbands;
            attr[1] = nrow;
            attr[2] = ncol;
            if (this->Fencode((void*)attr, sizeof(*attr), 3, file) < 3) {
               return FAILURE;
            }
            return SUCCESS;
         }
   
         Pobject* Mask( const Pobject* mask ) {
            if ((!mask)
                || (mask->Type() != Po_Reg2d)
                || (reinterpret_cast<const Imx2d < Long >*>(mask))->Size() != Size()){
               std::cerr << "Warning: bad mask format... ignored" << std::endl;
               return this;
            }
            
            Imx2d < T > *objd = (Imx2d < T> *)Clone();
            const Imx2d < Long > *m = reinterpret_cast<const Imx2d < Long >*>(mask);
            for (int b = 0; b < nbands; b++) {
               Ulong *pm = (Ulong*)m->Vector(0);
               T *pp = objd->Vector(b);
               T *pq = Vector(b);
         
               for (int i = 0; i < matrixSize; i++, pp++, pq++, pm++) {
                  *pp = (*pm == 0)? 0 : *pq;
               }
            }
            return objd;
         }
   
   
         Pobject* UnMask( const Pobject* mask, const Pobject* reference ) {
            if ((!mask)
                || (mask->Type() != Po_Reg2d)
                || (reinterpret_cast<const Imx2d < Long >*>(mask)->Size() != Size())
                || (reference->Type() != Type())
                || (reinterpret_cast<const Imx2d < T >*>(reference)->Size() != Size())) {
               std::cerr << "Warning: bad unmask format... ignored" << std::endl;
               return this;
            }
      
            const Imx2d < T > *objs = reinterpret_cast<const Imx2d < T > *>(reference);
            const Imx2d < Long > *m = reinterpret_cast<const Imx2d < Long > *>(mask);
            Imx2d < T > *objd = (Imx2d < T > *)Clone();
            for (int b = 0; b < nbands; b++) {
               Ulong *pm = (Ulong*)m->Vector(0);
               T *pp = objd->Vector(b);
               T *pq = Vector(b);
               T *ps = objs->Vector(b);
         
               for (int i = 0; i<matrixSize; i++, pp++, pq++, pm++, ps++) {
                  *pp = (*pm == 0) ? *ps : *pq;
               }
            }
            return objd;
         }
   
         bool Hold( Long y, Long x ) const { return (y >= 0) && (y < nrow) && (x >= 0) && (x < ncol); }

         bool Hold( const Point2d &pt ) const { return (pt.y >= 0) && (pt.y < nrow) && (pt.x >= 0) && ( pt.x < ncol); }

         Errc Frame( ValueType val, Long h ) { return Imx3d < T>::Frame(val, 0, h, h ); }

         Errc Frame( ValueType val, Long h, Long l ) { return Imx3d < T>::Frame(val, 0, h, l); }

         template < typename U >
         Errc Frame( const Imx2d < U > &ims, Long h ) { return Imx3d < T>::Frame(ims, 0, h, h); }

         template < typename U >
         Errc Frame( const Imx2d < U > &ims, Long h, Long l ) { return Imx3d < T>::Frame(ims, 0, h, l); }

         Border2DIterator *getBorderIterator( int c1, int c2, int c3, int c4 ) const {
            return new Border2DIterator(Size(), c1, c2, c3, c4);
         }

         Imx2d( const Imx2d  &ims ): Imx3d < T>( ) { New(ims.Props()); *this = ims; }
   };


   template <class T>
   class Imx1d: public Imx3d < T > {
      protected:
         using Imx3d < T>::_data;
         using Imx3d < T>::ncol;
         using Imx3d < T>::nbands; 
         using Imx3d < T>::ColorSpace;
         
      public:
         typedef T ValueType;

         Typobj Type( ) const { return ( Typobj )Po_type< Imx1d < T > >::type; }

         std::string Name( ) const { return TypeName< Imx1d < T > >::Name( ); }

         Dimension1d Size( ) const{ return Dimension1d( ncol ); }
   
         Imx1d( ): Imx3d < T>( ) { }
   
         Imx1d( Long b, Long w, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(b, w, data, isOwner); }

         Imx1d( Long b, const Dimension1d &d, T *data = 0, bool isOwner = false ): Imx3d < T>( ) {
            New(b, d.w, data, isOwner);
         }

         Imx1d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx3d < T>( ) {
            New(p, data, isOwner);
         }

         void New( Long b, Long w, T *data = 0, bool isOwner = false ) {
            Imx3d < T>::New(b, 1, 1, w, data, isOwner);
         }

         void New( Long b, const Dimension1d &d, T *data = 0, bool isOwner = false ) {
            New(b, d.w, data, isOwner);
         }

         void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) {
            New(p.nbands, p.ncol, data, isOwner); ColorSpace(p.colorspace);
         }

         Pobject* Clone( ) const {
            Imx1d < T > *tmp = new Imx1d < T >(nbands, ncol);
            *tmp = *this;
      
            return tmp;
         }
   
         /*   
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Imx1d < T > &operator=( const T val ) { Imx3d < T>::operator=( val ); return *this; }

         template< typename U >
         Imx1d < T > &operator=( const Imx1d < U > &src ) { Imx3d < T>::operator=( src ); return *this; }

         Imx1d < T > &operator=( const Imx1d < T > &src ) { Imx3d < T>::operator=( src ); return *this; }

         T* Vector( Long band = 0 ) const { return &_data[ncol * band]; }

         typename Imx3d < T>::Band1d operator[]( Long band ) {
            return typename Imx3d < T>::Band1d(this, &_data[ncol * band]);
         }

         const typename Imx3d < T>::Band1d operator[]( Long band ) const { return typename Imx3d < T>::Band1d(this, &_data[ncol * band]); } 

         T &operator()( Long b, Long x ) { return _data[ncol * b + x]; }

         const T &operator()( Long b, Long x ) const { return _data[ncol * b + x]; }

         T &operator()( Long b, Point1d &p ) { return _data[ncol * b + p.x]; }

         const T &operator()( Long b, Point1d &p ) const { return _data[ncol * b + p.x]; }

         Errc LoadAttributes( FILE* file ) {
            Long attr[2];
      
            if (this->Fdecode((void*)attr, sizeof(*attr), 2, file) < 2) {
               return FAILURE;
            }
            New(attr[0], attr[1]);
            return SUCCESS;
         }
   
         Errc SaveAttributes( FILE* file ) const {
            Long attr[2];
      
            attr[0] = nbands; attr[1] = ncol; 
            if (this->Fencode((void*)attr, sizeof(*attr), 2, file) < 2) {
               return FAILURE;
            }
            return SUCCESS;
         }
   
         Pobject* Mask( const Pobject* mask ) {
            if ((!mask)
                || (mask->Type() != Po_Reg1d)
                || (reinterpret_cast<const Imx1d < Long >*>(mask)->Size() != Size())) {
               std::cerr << "Warning: bad mask format... ignored" << std::endl;
               return this;
            }
      
            Imx1d < T > *objd = (Imx1d < T >*)Clone();
            const Imx1d < Long > *m = reinterpret_cast<const Imx1d < Long >*>(mask);
            for (int b = 0; b < nbands; b++) {
               Ulong *pm = (Ulong*)m->Vector(0);
               T *pp = objd->Vector(b);
               T *pq = Vector(b);
         
               for (int i = 0; i < ncol; i++, pp++, pq++, pm++) {
                  *pp = (*pm == 0) ? 0 : *pq;
               }         
            }  
            return objd;
         }

         Pobject* UnMask( const Pobject* mask, const Pobject* reference ) {
            if ((!mask)
                || (mask->Type() != Po_Reg1d)
                || (reinterpret_cast<const Imx1d < Long >*>(mask)->Size() != Size())
                || (reference->Type() != Type())
                || (reinterpret_cast<const Imx1d < T>*>(reference)->Size() != Size())) {
               std::cerr << "Warning: bad unmask format... ignored" << std::endl;
               return this;
            }
            if ((mask == NULL) || (mask->Type() != Po_Reg1d) || (reference->Type() != Type())) {
               return this;
            }

            const Imx1d < T > *objs = reinterpret_cast<const Imx1d < T > *>(reference);
            const Imx1d < Long > *m = reinterpret_cast<const Imx1d < Long >*>(mask);
            Imx1d < T > *objd = (Imx1d < T > *)Clone();
            for (int b = 0; b < nbands; b++) {
               Ulong *pm = (Ulong*)m->Vector(0);
               T *pp = objd->Vector(b);
               T *pq = Vector(b);
               T *ps = objs->Vector(b);
         
               for (int i = 0; i < ncol; i++, pp++, pq++, pm++, ps++) {
                  *pp = (*pm == 0) ? *ps : *pq;
               }
            }
            return objd;
         }
   
         bool Hold( Long x ) const { return (x >= 0) && (x < ncol); }

         bool Hold( const Point1d &pt ) const { return (pt.x >= 0) && (pt.x < ncol); }

         Errc Frame( ValueType val, Long l ) { return Imx3d < T>::Frame(val, 1, 1, l); }

         template < typename U >
         Errc Frame( const Imx1d < U > &ims, Long l ) { return Imx3d < T>::Frame(ims, 1, 1, l); }

         Imx1d( const Imx1d  &ims ): Imx3d < T>()  {
            New(ims.Props());
            *this = ims;
         }
   };


   template <class T>
   class Img1d: public Imx1d < T> {
      protected:
         using Imx1d < T>::ncol;
         using Imx1d < T>::nbands;
         using Imx1d < T>::ColorSpace;

      public:
         typedef T ValueType;

         Typobj Type( ) const { return ( Typobj )Po_type< Img1d < T > >::type; }

         std::string Name( ) const { return TypeName< Img1d < T > >::Name( ); }
   
         Img1d( ): Imx1d < T>( ) { }

         Img1d( Long w, T *data = 0, bool isOwner = false ): Imx1d < T>( ) { New(w, data, isOwner); }

         Img1d( const Dimension1d &d, T *data = 0, bool isOwner = false ): Imx1d < T>( ) { New(d.w, data, isOwner); }
   
         Img1d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx1d < T>( ) { New(p, data, isOwner); }
   
         void New( Long w, T *data = 0, bool isOwner = false ) { Imx1d < T>::New(1, w, data, isOwner); }

         void New( const Dimension1d &d, T *data = 0, bool isOwner = false ) { New(d.w, data, isOwner); }

         void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) { New(p.ncol, data, isOwner); ColorSpace(p.colorspace); }

         Pobject* Clone( ) const {
            Img1d < T > *tmp = new Img1d < T >(ncol);
            *tmp = *this;
            return tmp;
         }
   
         // No inheritance of operator= ! Overload.
         /*   
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Img1d < T > &operator=( const T val ) {
            Imx1d < T>::operator=(val);
            return *this;
         }

         template< typename U >
         Img1d < T > &operator=( const Img1d < U > &src ) {
            Imx1d < T>::operator=(src);
            return *this;
         }

         Img1d < T > &operator=( const Img1d < T > &src ) {
            Imx1d < T>::operator=(src);
            return *this;
         }

         ValueType* Vector( ) const { return Imx1d < T>::Vector( 0 ); }

         ValueType &operator[]( Long col ) { return Imx1d < T>::operator()(0, col); }

         const ValueType &operator[]( Long col ) const { return Imx1d < T>::operator()(0, col); }

         ValueType &operator()( Long x ) { return Imx1d < T>::operator()(0, x); }

         ValueType &operator[]( const Point1d &p ) { return Imx1d < T>::operator()(0, p.x); }

         const ValueType &operator[]( const Point1d &p ) const { return Imx1d < T>::operator()(0, p.x); }

         ValueType &operator()( const Point1d &p ) { return Imx1d < T>::operator()(0, p.x); }

         const ValueType &operator()( const Point1d &p ) const { return Imx1d < T>::operator()(0, p.x); }

         Img1d( const Img1d  &ims ): Imx1d < T>()  { New(ims.Props()); *this = ims; }
   };


   template< typename T > 
   class Img2d: public Imx2d < T> {
      protected:
         using Imx2d < T>::nbands;
         using Imx2d < T>::nrow;
         using Imx2d < T>::ncol;
         using Imx2d < T>::ColorSpace;

      public:
         typedef T ValueType;

         Typobj Type( ) const { return ( Typobj )Po_type< Img2d < T > >::type; }

         std::string Name( ) const { return TypeName< Img2d < T > >::Name( ); }

         Img2d( ): Imx2d < T>( ) {}

         Img2d( Long h, Long w, T *data = 0, bool isOwner = false ): Imx2d < T>( ) { New(h, w, data, isOwner); }

         Img2d( const Dimension2d &d, T *data = 0, bool isOwner = false ): Imx2d < T>( ) { New(d.h, d.w, data, isOwner); }
   
         Img2d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx2d < T>( ) { New(p, data, isOwner); }

         void New( Long h, Long w, T *data = 0, bool isOwner = false ) { Imx2d < T>::New(1, h, w, data, isOwner); }

         void New( const Dimension2d &d, T *data = 0, bool isOwner = false ) { New(d.h, d.w, data, isOwner); }

         void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) { New(p.nrow, p.ncol, data, isOwner); ColorSpace(p.colorspace); }
 
         Pobject* Clone( ) const {
            Img2d < T > *tmp = new Img2d < T >(nrow, ncol);
            *tmp = *this;
            return tmp;
         }
         // No inheritance of operator= ! Overload.

         /*   
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Img2d < T > &operator=( const T val ) {
            Imx2d < T>::operator=( val );
            return *this;
         }

         template< typename U >
         Img2d < T > &operator=( const Img2d < U > &src ) {
            Imx2d < T>::operator=( src );
            return *this;
         }

         Img2d < T > &operator=( const Img2d < T > &src ) {
            Imx2d < T>::operator=( src );
            return *this;
         }

         ValueType* Vector( ) const {
            return Imx2d < T>::Vector( 0 );
         }


         typename Imx3d < T>::Band1d operator[]( Long row ) { return Imx2d < T>::operator[](0)[row]; }

         const typename Imx3d < T>::Band1d operator[]( Long row ) const { return Imx2d < T>::operator[](0)[row]; }

         ValueType &operator()( Long y, Long x ) { return Imx2d < T>::operator()(0, y, x); }

         const ValueType &operator()( Long y, Long x ) const { return Imx2d < T>::operator()(0, y, x); }

         ValueType &operator[]( const Point2d &p ) { return Imx2d < T>::operator()(0, p.y, p.x); }

         const ValueType &operator[]( const Point2d &p ) const { return Imx2d < T>::operator()(0, p.y, p.x); }

         ValueType &operator()( int, const Point2d &p ) { return Imx2d < T>::operator()(0, p.y, p.x); }

         const ValueType &operator()( int, const Point2d &p ) const { return Imx2d < T>::operator()(0, p.y, p.x); }

         ValueType &operator()( const Point2d &p ) { return Imx2d < T>::operator()(0, p.y, p.x); }

         const ValueType &operator()( const Point2d &p ) const { return Imx2d < T>::operator()(0, p.y, p.x); }

         Img2d( const Img2d  &ims ): Imx2d < T>() { New(ims.Props()); *this = ims; }
   };


   template <typename T>
   class Img3d: public Imx3d < T> {
      protected:
         using Imx3d < T>::nbands;
         using Imx3d < T>::ncol;
         using Imx3d < T>::nrow;
         using Imx3d < T>::ndep;
         using Imx3d < T>::ColorSpace;

      public:
         typedef T ValueType;


         Typobj Type( ) const { return ( Typobj )Po_type< Img3d < T > >::type; }

         std::string Name( ) const { return TypeName< Img3d < T > >::Name( ); }

         Img3d( ): Imx3d < T>( ) { }
   
         Img3d( Long d, Long h, Long w, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(d, h, w, data, isOwner); }
   
         Img3d( const Dimension3d &d, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(d.d, d.h, d.w, data, isOwner); }
   
         Img3d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(p, data, isOwner); }
   
         void New( Long d, Long h, Long w, T *data = 0, bool isOwner = false ) {
            Imx3d < T>::New(1, d, h, w, data, isOwner);
         }

         void New( const Dimension3d &d, T *data = 0, bool isOwner = false ) {
            New(d.d, d.h, d.w, data, isOwner);
         }

         void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) {
            New(p.ndep, p.nrow, p.ncol, data, isOwner);
            ColorSpace(p.colorspace);
         }

         Pobject* Clone( ) const {
            Img3d < T > *tmp = new Img3d < T >(ndep, nrow, ncol);
            *tmp = *this;
            return tmp;
         }

         // No inheritance of operator= ! Overload.

         /*   
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Img3d < T > &operator=( const T val ) {
            Imx3d < T>::operator=( val );
            return *this;
         }

         template< typename U >
         Img3d < T > &operator=( const Img3d < U > &src ) { Imx3d < T>::operator=( src ); return *this; }

         Img3d < T > &operator=( const Img3d < T > &src ) { Imx3d < T>::operator=( src ); return *this; }

         ValueType* Vector( ) const { return Imx3d < T>::Vector(0); }

         typename Imx3d < T>::Band2d operator[]( Long dep ) { return Imx3d < T>::operator[](0)[dep]; }
         
         const typename Imx3d < T>::Band2d operator[]( Long dep ) const { return Imx3d < T>::operator[](0)[dep]; }

         ValueType &operator()( Long z, Long y, Long x ) { return Imx3d < T>::operator()(0, z, y, x); }

         const ValueType &operator()( Long z, Long y, Long x ) const { return Imx3d < T>::operator()(0, z, y, x); }

         ValueType &operator[]( const Point3d &p ) {return operator()(p.z, p.y, p.x); }

         const ValueType &operator[]( const Point3d &p ) const { return operator()(p.z, p.y, p.x); }

         ValueType &operator()( const Point3d &p ) {return operator()(p.z, p.y, p.x); }

         const ValueType &operator()( const Point3d &p ) const { return operator()(p.z, p.y, p.x); }

         const ValueType &operator()( int, const Point3d &p ) const { return operator()(p.z, p.y, p.x); }

         ValueType &operator()( int, const Point3d &p ) {return operator()(p.z, p.y, p.x); }

         Img3d( const Img3d  &ims ): Imx3d < T>() {
            New(ims.Props());
            *this = ims;
         }
   };


   template< typename T > 
   class Imc2d: public Imx2d < T> {
      protected:
         using Imx2d < T>::nbands;
         using Imx2d < T>::ncol;
         using Imx2d < T>::nrow;
         
      public:
         using Imx2d < T>::ColorSpace;

         typedef T ValueType;

         typename Imx3d < T>::Band2d X;

         typename Imx3d < T>::Band2d Y;

         typename Imx3d < T>::Band2d Z;

         Typobj Type( ) const { return ( Typobj )Po_type< Imc2d < T > >::type; }

         std::string Name( ) const { return TypeName< Imc2d < T > >::Name( ); }

         Imc2d( ): Imx2d < T>( ) { }

         Imc2d( Long h, Long w, T *data = 0, bool isOwner = false ): Imx2d < T> ( ) {
            New(h, w, data, isOwner);
         }

         Imc2d( const Dimension2d &d, T *data = 0, bool isOwner = false ): Imx2d < T>( ) {
            New(d, data, isOwner);
         }

         Imc2d( Long b, const Dimension2d &d, T *data = 0, bool isOwner = false ): Imx2d < T>( ) {
            New(b, d.h, d.w, data, isOwner);
         }

         Imc2d( Long b, Long h, Long w, T *data = 0, bool isOwner = false ): Imx2d < T>( ) {
            New(b, h, w, data, isOwner);
         }
         
         Imc2d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx2d < T>( ) {
            New(p, data, isOwner);
         }

         void New( Long h, Long w, T *data = 0, bool isOwner = false ) {
            Imx2d < T>::New(3, h, w, data, isOwner);
            // Kept for sake of compatibility.
            X.New(this, Imx2d < T>::Vector(0));
            Y.New(this, Imx2d < T>::Vector(1));
            Z.New(this, Imx2d < T>::Vector(2));
         }

         void New( Long /*b*/, Long h, Long w, T *data = 0, bool isOwner = false ) { New(h, w, data, isOwner); }

         void New( const Dimension2d &d, T *data = 0, bool isOwner = false ) { New(d.h, d.w, data, isOwner); }

         void New( Long /*b*/, const Dimension2d &d, T *data = 0, bool isOwner = false ) { New(d.h, d.w, data, isOwner); }

         void New( const PobjectProps &p, T *data = 0, bool isOwner = false ) {
            ColorSpace(p.colorspace);
            New(p.nrow, p.ncol, data, isOwner);
         }

         Pobject* Clone( ) const {
            Imc2d < T > *tmp = new Imc2d < T >(nrow, ncol);
            *tmp = *this;
            return tmp;
         }
   
         // No inheritance of operator=( ) ! Overload.

         /*   
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Imc2d < T > &operator=( const T val ) {
            Imx2d < T>::operator=( val );
            return *this;
         }

         template< typename U >
         Imc2d < T > &operator=( const Imc2d < U > &src ) { Imx2d < T>::operator=( src ); return *this; }

         Imc2d < T > &operator=( const Imc2d < T > &src ) { Imx2d < T>::operator=( src ); return *this; }

         ValueType* VectorX( ) const { return Imx2d < T>::Vector( 0 ); }

         ValueType* VectorY( ) const { return Imx2d < T>::Vector( 1 ); }

         ValueType* VectorZ( ) const { return Imx2d < T>::Vector( 2 ); }

         // Transfer
         Errc LoadAttributes( FILE *file ) {
            Long attr[3];

            if (this->Fdecode((void*)attr, sizeof(*attr), 3, file) < 3) {
               return FAILURE;
            }
            New(attr[1], attr[2]);
      
            PColorSpace c;
            if (this->Fdecode((void*)&c, sizeof(c), 1, file) < 1) {
               return FAILURE;
            }
            ColorSpace(c);
            return SUCCESS;
         }
   
         Errc SaveAttributes( FILE *file ) const {
            if (Imx2d < T>::SaveAttributes(file) == FAILURE) {
               return FAILURE;
            }
      
            PColorSpace c = ColorSpace();
            if (this->Fencode((void*)&c, sizeof(c), 1, file) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   
         Imc2d( const Imc2d  &ims ): Imx2d < T>() {
            New(ims.Props());
            *this = ims;
         }
   };
   

   template< typename T > 
   class Imc3d: public Imx3d < T> {
      protected:
         using Imx3d < T>::nbands;
         using Imx3d < T>::ncol;
         using Imx3d < T>::nrow;
         using Imx3d < T>::ndep;

      public:
         using Imx3d < T>::ColorSpace;

         typedef T ValueType;

         typename Imx3d < T>::Band3d X;

         typename Imx3d < T>::Band3d Y;

         typename Imx3d < T>::Band3d Z;

         Typobj Type( ) const { return ( Typobj )Po_type< Imc3d < T > >::type; }

         std::string Name( ) const { return TypeName< Imc3d <T> >::Name( ); }

         Imc3d( ): Imx3d < T>( ) { }

         Imc3d( Long b, Long d, Long h, Long w, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(b, d, h, w, data, isOwner); }

         Imc3d( Long b, const Dimension3d &d, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(b, d, data, isOwner); }

         Imc3d( Long d, Long h, Long w, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(d, h, w, data, isOwner); }

         Imc3d( const Dimension3d &d, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(d, data, isOwner); }
 
         Imc3d( const PobjectProps &p, T *data = 0, bool isOwner = false ): Imx3d < T>( ) { New(p, data, isOwner); }
   
         void New( Long /*b*/, Long d, Long h, Long w, T *data = 0, bool isOwner = false ) { New(d, h, w, data, isOwner); } 

         void New( Long /*b*/, const Dimension3d &d, T *data = 0, bool isOwner = false ) { New(d.d, d.h, d.w, data, isOwner); }

         void New( Long d, Long h, Long w, T *data = 0, bool isOwner = false ) {
            Imx3d < T>::New(3, d, h, w, data, isOwner);
            // Kept for sake of compatibility.
            X.New(this, Imx3d < T>::Vector(0));
            Y.New(this, Imx3d < T>::Vector(1));
            Z.New(this, Imx3d < T>::Vector(2));
         }
         void New( const Dimension3d &d, T *data = 0, bool isOwner = false ) {
            New(d.d, d.h, d.w, data, isOwner);
         }

         void New( const PobjectProps &p, T* data = 0, bool isOwner = false ) {
            ColorSpace(p.colorspace);
            New(p.ndep, p.nrow, p.ncol, data, isOwner);
         }

         Pobject* Clone( ) const {
            Imc3d < T > *tmp = new Imc3d < T >(ndep, nrow, ncol);
            *tmp = *this;
            return tmp;
         }
   
         // No inheritance of operator= ! Overload.

         /*
          * Sets all pixels with the given value.
          * @param val  the given value.
          * @return the image itself.
          */
         Imc3d < T > &operator=( const T val ) {
            Imx3d < T>::operator=(val);
            return *this;
         }

         template< typename U >
         Imc3d < T > &operator=( const Imc3d < U > &src ) {
            Imx3d < T>::operator=(src);
            return *this;
         }

         Imc3d < T > &operator=( const Imc3d < T > &src ) {
            Imx3d < T>::operator=(src);
            return *this;
         }

         ValueType* VectorX( ) const {
            return Imx3d < T>::Vector(0);
         }

         ValueType* VectorY( ) const {
            return Imx3d < T>::Vector(1);
         }
   
         ValueType* VectorZ( ) const {
            return Imx3d < T>::Vector(2);
         }

         Errc LoadAttributes( FILE *file ) {
            Long attr[4];
            // Remarque ; attr[0] = nbands. Always =3.
            if (this->Fdecode((void*)attr, sizeof(*attr), 4, file) < 4) {
               return FAILURE;
            }
            New(attr[1], attr[2], attr[3]);
      
            PColorSpace c;
            if (this->Fdecode((void*)&c, sizeof(c), 1, file) < 1) {
               return FAILURE;
            }
            ColorSpace(c);
            return SUCCESS;
         }

         Errc SaveAttributes( FILE *file ) const {
            if (Imx3d < T>::SaveAttributes(file) == FAILURE) {
               return FAILURE;
            }
            PColorSpace c=ColorSpace();
            if (this->Fencode((void*)&c, sizeof(c), 1, file) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   
         Imc3d( const Imc3d  &ims ): Imx3d < T>() { New(ims.Props()); *this = ims; }
   };

   typedef Imx1d < Uchar >  Imx1duc;
   typedef Imx1d < Long  >  Imx1dsl;
   typedef Imx1d < Float >  Imx1dsf;

   typedef Imx2d < Uchar >  Imx2duc;
   typedef Imx2d < Long >   Imx2dsl;
   typedef Imx2d < Float >  Imx2dsf;

   typedef Imx3d < Uchar >  Imx3duc;
   typedef Imx3d < Long >   Imx3dsl;
   typedef Imx3d < Float >  Imx3dsf;

   typedef Img1d < Uchar >  Img1duc;
   typedef Img1d < Long >   Img1dsl;
   typedef Img1d < Float >  Img1dsf;

   typedef Img2d < Uchar >  Img2duc;
   typedef Img2d < Long >   Img2dsl;
   typedef Img2d < Float >  Img2dsf;

   typedef Img3d < Uchar >  Img3duc;
   typedef Img3d < Long >   Img3dsl;
   typedef Img3d < Float >  Img3dsf;

   typedef Imc2d < Uchar >  Imc2duc;
   typedef Imc2d < Long >   Imc2dsl;
   typedef Imc2d < Float >  Imc2dsf;

   typedef Imc3d < Uchar >  Imc3duc;
   typedef Imc3d < Long >   Imc3dsl;
   typedef Imc3d < Float >  Imc3dsf;

/* @brief The magic number for the type Img1duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img1duc.
 */
   template<> struct Po_type<Img1duc> {
         enum {type = Po_Img1duc };
   };

/* @brief Trait that returns the name of the Pandore type Img1duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img1duc > {
         static std::string Name( ) { return "Img1duc"; }
   };
/* @brief The magic number for the type Img1dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img1dsl.
 */
   template<> struct Po_type<Img1dsl> {
         enum {type = Po_Img1dsl };
   };

/* @brief Trait that returns the name of the Pandore type Img1dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img1dsl > {
         static std::string Name( ) { return "Img1dsl"; }
   };
/* @brief The magic number for the type Img1dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img1dsf.
 */
   template<> struct Po_type<Img1dsf> {
         enum {type = Po_Img1dsf };
   };

/* @brief Trait that returns the name of the Pandore type Img1dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img1dsf > {
         static std::string Name( ) { return "Img1dsf"; }
   };
/* @brief The magic number for the type Img2duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img2duc.
 */
   template<> struct Po_type<Img2duc> {
         enum {type = Po_Img2duc };
   };

/* @brief Trait that returns the name of the Pandore type Img2duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img2duc > {
         static std::string Name( ) { return "Img2duc"; }
   };
/* @brief The magic number for the type Img2dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img2dsl.
 */
   template<> struct Po_type<Img2dsl> {
         enum {type = Po_Img2dsl };
   };

/* @brief Trait that returns the name of the Pandore type Img2dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img2dsl > {
         static std::string Name( ) { return "Img2dsl"; }
   };
/* @brief The magic number for the type Img2dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img2dsf.
 */
   template<> struct Po_type<Img2dsf> {
         enum {type = Po_Img2dsf };
   };

/* @brief Trait that returns the name of the Pandore type Img2dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img2dsf > {
         static std::string Name( ) { return "Img2dsf"; }
   };
/* @brief The magic number for the type Img3duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img3duc.
 */
   template<> struct Po_type<Img3duc> {
         enum {type = Po_Img3duc };
   };

/* @brief Trait that returns the name of the Pandore type Img3duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img3duc > {
         static std::string Name( ) { return "Img3duc"; }
   };
/* @brief The magic number for the type Img3dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img3dsl.
 */
   template<> struct Po_type<Img3dsl> {
         enum {type = Po_Img3dsl };
   };

/* @brief Trait that returns the name of the Pandore type Img3dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img3dsl > {
         static std::string Name( ) { return "Img3dsl"; }
   };
/* @brief The magic number for the type Img3dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Img3dsf.
 */
   template<> struct Po_type<Img3dsf> {
         enum {type = Po_Img3dsf };
   };

/* @brief Trait that returns the name of the Pandore type Img3dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Img3dsf > {
         static std::string Name( ) { return "Img3dsf"; }
   };
/* @brief The magic number for the type Imc2duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imc2duc.
 */
   template<> struct Po_type<Imc2duc> {
         enum {type = Po_Imc2duc };
   };

/* @brief Trait that returns the name of the Pandore type Imc2duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imc2duc > {
         static std::string Name( ) { return "Imc2duc"; }
   };
/* @brief The magic number for the type Imc2dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imc2dsl.
 */
   template<> struct Po_type<Imc2dsl> {
         enum {type = Po_Imc2dsl };
   };

/* @brief Trait that returns the name of the Pandore type Imc2dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imc2dsl > {
         static std::string Name( ) { return "Imc2dsl"; }
   };
/* @brief The magic number for the type Imc2dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imc2dsf.
 */
   template<> struct Po_type<Imc2dsf> {
         enum {type = Po_Imc2dsf };
   };

/* @brief Trait that returns the name of the Pandore type Imc2dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imc2dsf > {
         static std::string Name( ) { return "Imc2dsf"; }
   };
/* @brief The magic number for the type Imc3duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imc3duc.
 */
   template<> struct Po_type<Imc3duc> {
         enum {type = Po_Imc3duc };
   };

/* @brief Trait that returns the name of the Pandore type Imc3duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imc3duc > {
         static std::string Name( ) { return "Imc3duc"; }
   };
/* @brief The magic number for the type Imc3dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imc3dsl.
 */
   template<> struct Po_type<Imc3dsl> {
         enum {type = Po_Imc3dsl };
   };

/* @brief Trait that returns the name of the Pandore type Imc3dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imc3dsl > {
         static std::string Name( ) { return "Imc3dsl"; }
   };
/* @brief The magic number for the type Imc3dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imc3dsf.
 */
   template<> struct Po_type<Imc3dsf> {
         enum {type = Po_Imc3dsf };
   };

/* @brief Trait that returns the name of the Pandore type Imc3dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imc3dsf > {
         static std::string Name( ) { return "Imc3dsf"; }
   };
/* @brief The magic number for the type Imx1duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx1duc.
 */
   template<> struct Po_type<Imx1duc> {
         enum {type = Po_Imx1duc };
   };

/* @brief Trait that returns the name of the Pandore type Imx1duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx1duc > {
         static std::string Name( ) { return "Imx1duc"; }
   };
/* @brief The magic number for the type Imx1dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx1dsl.
 */
   template<> struct Po_type<Imx1dsl> {
         enum {type = Po_Imx1dsl };
   };

/* @brief Trait that returns the name of the Pandore type Imx1dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx1dsl > {
         static std::string Name( ) { return "Imx1dsl"; }
   };
/* @brief The magic number for the type Imx1dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx1dsf.
 */
   template<> struct Po_type<Imx1dsf> {
         enum {type = Po_Imx1dsf };
   };

/* @brief Trait that returns the name of the Pandore type Imx1dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx1dsf > {
         static std::string Name( ) { return "Imx1dsf"; }
   };
/* @brief The magic number for the type Imx2duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx2duc.
 */
   template<> struct Po_type<Imx2duc> {
         enum {type = Po_Imx2duc };
   };

/* @brief Trait that returns the name of the Pandore type Imx2duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx2duc > {
         static std::string Name( ) { return "Imx2duc"; }
   };
/* @brief The magic number for the type Imx2dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx2dsl.
 */
   template<> struct Po_type<Imx2dsl> {
         enum {type = Po_Imx2dsl };
   };

/* @brief Trait that returns the name of the Pandore type Imx2dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx2dsl > {
         static std::string Name( ) { return "Imx2dsl"; }
   };
/* @brief The magic number for the type Imx2dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx2dsf.
 */
   template<> struct Po_type<Imx2dsf> {
         enum {type = Po_Imx2dsf };
   };

/* @brief Trait that returns the name of the Pandore type Imx2dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx2dsf > {
         static std::string Name( ) { return "Imx2dsf"; }
   };
/* @brief The magic number for the type Imx3duc.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx3duc.
 */
   template<> struct Po_type<Imx3duc> {
         enum {type = Po_Imx3duc };
   };

/* @brief Trait that returns the name of the Pandore type Imx3duc.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx3duc > {
         static std::string Name( ) { return "Imx3duc"; }
   };
/* @brief The magic number for the type Imx3dsl.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx3dsl.
 */
   template<> struct Po_type<Imx3dsl> {
         enum {type = Po_Imx3dsl };
   };

/* @brief Trait that returns the name of the Pandore type Imx3dsl.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx3dsl > {
         static std::string Name( ) { return "Imx3dsl"; }
   };
/* @brief The magic number for the type Imx3dsf.
 *
 * Po_Type is an helper class that defines the
 * magic number for the type Imx3dsf.
 */
   template<> struct Po_type<Imx3dsf> {
         enum {type = Po_Imx3dsf };
   };

/* @brief Trait that returns the name of the Pandore type Imx3dsf.
 *
 * TypeName is a trait that returns the name
 * of the Pandore type T.
 */
   template<> struct TypeName< Imx3dsf > {
         static std::string Name( ) { return "Imx3dsf"; }
   };

} //End of pandore:: namespace

#endif // __PIMAGEH__

---

The Pantheon project
Image Team GREYC Laboratory
UMR CNRS 6072 - ENSICAEN - University of Caen, France
This page was last modified on 19 June 2015