region.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 __PREGIONH__
#define __PREGIONH__

namespace pandore {

   // Definitions of region maps types.
   class Reg1d;
   class Reg2d;
   class Reg3d;

   /* @brief Trait that returns the name of the Pandore type TYPE.
    *
    * TypeName is a trait that retunrs the name
    * of the Pandore type T.
    */
   template<>
   struct TypeName< Reg1d > {
         static std::string Name() {
            return "Reg1d";
         }
   };
   
   /* @brief Trait that returns the name of the Pandore type TYPE.
    *
    * TypeName is a trait that retunrs the name
    * of the Pandore type T.
    */
   template<>
   struct TypeName< Reg2d > {
         static std::string Name() {
            return "Reg2d";
         }
   };
   
   
   /* @brief Trait that returns the name of the Pandore type TYPE.
    *
    * TypeName is a trait that retunrs the name
    * of the Pandore type T.
    */
   template<>
   struct TypeName< Reg3d > {
         static std::string Name() {
            return "Reg3d";
         }
   };
   
   class Reg1d: public Img1d<Long> {
      protected:
         Long nlabels;

      public:
         typedef Ulong ValueType;

         Typobj Type() const {
            return Po_Reg1d;
         }

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

         Ulong Labels() const {
            return nlabels;
         }

         Ulong Labels( Ulong n ) {
            return nlabels = n;
         }

         PobjectProps Props() const {
            return PobjectProps(nbands, ncol, 0, 0, (PColorSpace)0, nlabels, nlabels + 1);
         }
   
         Reg1d(): Img1d<Long>(), nlabels(0) {}

         Reg1d( Long w ): Img1d<Long>(w), nlabels(0) {}

         Reg1d( const Dimension1d& d ): Img1d<Long>(d), nlabels(0) {}

         Reg1d( const PobjectProps& p ): Img1d<Long>(p.ncol), nlabels(p.nlabels) {}
   
         void New( Long w ) { Img1d<Long>::New(w); nlabels = 0L; }

         void New( const Dimension1d& d ) { New(d.w); }

         void New( const PobjectProps& p ) {
            New(p.ncol);
            nlabels = p.nlabels;
         }

         void Delete () { Img1d<Long>::Delete(); nlabels = 0L; }

         Pobject* Clone( ) const {
            Reg1d *tmp = new Reg1d(ncol);
            *tmp = *this;
            return tmp;
         }

         ValueType* Vector() const {
            return (ValueType*)Img1d<Long>::Vector();
         }

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

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

         ValueType& operator[]( const Point1d& p ) {
            return (ValueType&)Imx1d<Long>::operator[](0)[p.x];
         }
   
         const ValueType& operator[]( const Point1d& p ) const {
            return reinterpret_cast<const ValueType&>(Imx1d<Long>::operator[](0)[p.x]);
         }
   
         Reg1d& operator=(const Reg1d::ValueType val) {
            Img1d<Long>::operator=(val);
            nlabels = (val > 0) ? val : 0;
            return *this;
         }

         Reg1d& operator=(const Reg1d &rgs) {
            nlabels = rgs.nlabels;
            memcpy(Vector(), rgs.Vector(), ncol * sizeof(Reg1d::ValueType));
            return *this;
         }
   
         Errc LoadAttributes( FILE *file );

         Errc SaveAttributes( FILE *file ) const;
   
         Errc LoadData( FILE *file );
   
         Errc SaveData( FILE *file ) const;
   
         Pobject *Mask( const Pobject *mask );
   
         Pobject *UnMask( const Pobject *mask, const Pobject *reference );
   
         Reg1d( const Reg1d &rgs ): Img1d<Long>() {
            New(rgs.Props());
            *this = rgs;
         } 
   };

   class Reg2d: public Img2d<Long> {
   public:
         class Band1dr {
            public:
               // 1D data accessors.
               explicit Band1dr( const Imx3d<Long> * const region, Long *offset ) : _region(region), _offset(offset) {}
               Ulong &operator[]( Long x ) {
                  return (Ulong&)_offset[x];
               }
               const Ulong &operator[]( Long x ) const {
                  return (Ulong&)_offset[x];
               }
            private:
               const Imx3d<Long> *_region;
               Long *_offset;
         };
         

         Ulong nlabels;

      public:
         typedef Ulong ValueType;

         Typobj Type() const {
            return Po_Reg2d;
         }

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

         Ulong Labels() const {
            return nlabels;
         }

         Ulong Labels( Ulong n ) {
            return nlabels = n;
         }

         PobjectProps Props() const {
            return PobjectProps(nbands, ncol, nrow, 0, (PColorSpace)0, nlabels, nlabels + 1);
         }
   
         Reg2d(): Img2d<Long>(), nlabels(0) {}

         Reg2d(Long h, Long w): Img2d<Long>(h, w), nlabels(0) {}

         Reg2d(const Dimension2d& d): Img2d<Long>(d), nlabels(0) {}

      Reg2d(const PobjectProps& p): Img2d<Long>(p.nrow, p.ncol), nlabels(p.nlabels) { }

         void New( Long h, Long w ) { Img2d<Long>::New(h, w); nlabels = 0L; }

         void New( const Dimension2d &d ) { New(d.h, d.w); }

         void New( const PobjectProps &p, Ulong * data = 0 ) {
            Img2d<Long>::New(p.nrow, p.ncol, (Long*)data);
            nlabels = p.nlabels;
         }
         
         void Delete() { Img2d<Long>::Delete(); nlabels = 0L; }

         Pobject* Clone( ) const {
            Reg2d *tmp = new Reg2d(nrow, ncol);
            *tmp = *this;
            return tmp;
         }

         ValueType* Vector() const {
            return (ValueType*)Img2d<Long>::Vector();
         }
      
         Band1dr operator[]( Long row ) {
            return Band1dr(this, &_data[ncol*row]);
         }

         const Band1dr operator[]( Long row ) const {
            return Band1dr(this, &_data[ncol*row]);
         }

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

         ValueType& operator[]( const Point2d& p ) {
            return (ValueType&) Imx2d<Long>::operator()(0, p.y, p.x);
         }
   
         const ValueType& operator[]( const Point2d& p ) const {
            return reinterpret_cast<const ValueType&>(Imx2d<Long>::operator()(0, p.y, p.x));
         }
   
         Reg2d& operator=( const Reg2d::ValueType val ) {
            Img2d<Long>::operator=(val);
            nlabels = (val > 0) ? val : 0;
            return *this;
         }

         Reg2d& operator=( const Reg2d &rgs ) {
            nlabels = rgs.nlabels;
            memcpy(Vector(), rgs.Vector(), nrow * ncol * sizeof(Reg2d::ValueType));
            return *this;
         }
   
         Errc LoadAttributes( FILE *file );

         Errc SaveAttributes( FILE *file ) const;
         Errc LoadData( FILE *file );

         Errc SaveData( FILE *file ) const;

         Pobject* Mask( const Pobject *mask );

         Pobject* UnMask( const Pobject *mask, const Pobject *reference );

         Reg2d( const Reg2d &rgs ): Img2d<Long>() {
            New(rgs.Props());
            *this = rgs;
         }
   };

   class Reg3d: public Img3d<Long> {
         class Band2dr {
            public:
               // 2D data accessors.
               explicit Band2dr( const Imx3d<Long> *region, Long *offset ) : _region(region), _offset(offset) {}
               explicit Band2dr(): _region(0), _offset(0) {};
               Reg2d::Band1dr operator[]( Long y ) {
                  return Reg2d::Band1dr(_region, &_offset[_region->Width() * y]);
               }
               const Reg2d::Band1dr operator[]( Long y ) const {
                  return Reg2d::Band1dr(_region, &_offset[_region->Width() * y]);
               }
         private:
               const Imx3d<Long> *_region;
               Long *_offset;
         };
      protected:
         Ulong nlabels;

      public:
         typedef Ulong ValueType;

         Typobj Type() const {
            return Po_Reg3d;
         }

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

         Ulong Labels() const {
            return nlabels;
         }

         Ulong Labels( Ulong n ) {
            return nlabels = n;
         }

         PobjectProps Props() const {
            return PobjectProps(nbands, ncol, nrow, ndep, (PColorSpace)0, nlabels, nlabels + 1);
         }

         Reg3d(): Img3d<Long>(), nlabels(0) {}

         Reg3d( Long d, Long h, Long w ): Img3d<Long>(d, h, w), nlabels(0) {}

         Reg3d( const Dimension3d& d ): Img3d<Long>(d), nlabels(0) {}

         Reg3d(const PobjectProps& p): Img3d<Long>(p.ndep, p.nrow, p.ncol), nlabels(p.nlabels) {}

         void New( Long d, Long h, Long w ) { Img3d<Long>::New(d, h, w); nlabels = 0L; }

         void New( const Dimension3d& d ) { New(d.d, d.h, d.w); }

         void New( const PobjectProps& p, Long *data = 0 ) {
            Img3d<Long>::New(p.ndep, p.nrow, p.ncol, (Long*)data);
            nlabels = p.nlabels;
         }

         void Delete () { Img3d<Long>::Delete(); nlabels = 0L; }

         Pobject* Clone( ) const {
            Reg3d *tmp = new Reg3d(ndep, nrow, ncol);
            *tmp = *this;
            return tmp;
         }

         ValueType* Vector() const {
            return (ValueType*)Img3d<Long>::Vector(); 
            
         }

         Reg3d& operator=( const Reg3d::ValueType val ) {
            Img3d<Long>::operator=(val);
            nlabels = (val > 0) ? val : 0;
            return *this;
         }

         Reg3d& operator=( const Reg3d &rgs ) {
            nlabels = rgs.nlabels;
            memcpy(Vector(), rgs.Vector(), ndep * nrow * ncol * sizeof(Reg3d::ValueType));
            return *this;
         }

         Band2dr operator[]( Long dep ) {
            return Band2dr(this, &_data[matrixSize * dep]);
         }

         const Band2dr operator[]( Long dep ) const {
            return Band2dr(this, &_data[matrixSize * dep]);
         }

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

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

         ValueType& operator[]( const Point3d& p ) {
            return (ValueType&) Imx3d<Long>::operator()(0, p.z, p.y, p.x);
         }

         const ValueType& operator[]( const Point3d& p ) const {
            return reinterpret_cast<const ValueType&>(Imx3d<Long>::operator()(0, p.z, p.y, p.x));
         }

         Errc LoadAttributes( FILE *file );

         Errc SaveAttributes( FILE *file ) const;

         Errc LoadData( FILE *file );

         Errc SaveData( FILE *file ) const;

         Pobject* Mask( const Pobject *mask );

         Pobject* UnMask( const Pobject *mask, const Pobject *reference );

         Reg3d( const Reg3d &rgs ): Img3d<Long>() {
            New(rgs.Props());
            *this = rgs;
         }
   };
   
} //End of pandore:: namespace
#endif // __PREGIONH__

---

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