dimension.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 __PDIMENSIONH__
#define __PDIMENSIONH__

namespace pandore {

   class Dimension1d;
   class Dimension2d;
   class Dimension3d;

/* @brief A trait that returns the name of the object Dimension1d.
 *
 * TypeName is a trait that returns the name
 * of the object Dimension1d.
 */
   template<>
   struct TypeName< Dimension1d > {
         /*
          * Returns the name of the type.
          * @return     the string with the name.
          */
         static ::std::string Name() { return "Dimension1d"; }
   };

   /* @brief A trait that returns the name of the object Dimension2d.
    *
    * TypeName is a trait that returns the name
    * of the object Dimension2d.
    */
   template<>
   struct TypeName< Dimension2d > {
         /*
          * Returns the name of the type.
          * @return     the string with the name.
          */
         static std::string Name() { return "Dimension2d"; }
   };

   /* @brief A trait that returns the name of the object Dimension3d.
    *
    * TypeName is a trait that returns the name
    * of the object Dimension3d.
    */
   template<>
   struct TypeName< Dimension3d > {
         /*
          * Returns the name of the type.
          * @return     the string with the name.
          */
         static std::string Name() { return "Dimension3d"; }
   };

   class Dimension: public Pobject {
      protected:
         Dimension() {}
   
      public:
         ~Dimension() {}

         Pobject* Mask( const Pobject * /*mask*/ ) {
            return this;
         }

         Pobject* UnMask( const Pobject * /*mask*/, const Pobject * /*reference*/ ) {
            return this; 
         } 

         Errc LoadAttributes( FILE* /*df*/ ) {
            return SUCCESS;
         }

         Errc SaveAttributes( FILE* /*df*/ ) const {
            return SUCCESS;
         }
   };

   class Dimension1d: public Dimension {
      public:
         Long w;

         Typobj Type() const { return Po_Dimension1d; } 
   
         std::string Name() const { return TypeName< Dimension1d >::Name(); }

         Dimension1d(): Dimension(), w(0) {}
   
         Dimension1d( Long width ): Dimension(), w(width) {}

         Dimension1d( const Dimension1d& d ): Dimension(), w(d.w) {}

         const Dimension1d& operator=( const Dimension1d& d ) {
            w = d.w;
            return *this;
         }

         bool operator==( const Dimension1d& d ) const {
            return d.w == w;
         }

         bool operator!=( const Dimension1d& d ) const {
            return !(d == *this);
         }

         Dimension1d operator+( int x ) const {
            return Dimension1d(w + x);
         }

         Dimension1d operator-( int x ) const {
            return Dimension1d(w - x);
         }

         Dimension1d operator*( int x ) const {
            return Dimension1d(w * x);
         }

         Dimension1d operator/( int x ) const {
            return Dimension1d(w / x);
         }
         
         Pobject* Clone() const {
            return new Dimension1d(w);
         }   

         Errc LoadData( FILE *df ) {
            if (this->Fdecode(&w, sizeof(w), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
  
         Errc SaveData( FILE *df ) const {
            if (this->Fencode(&w, sizeof(w), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   };

   inline const Dimension1d operator*( int x, const Dimension1d &d ) {
      return Dimension1d(d.w * x);
   }
   
   class Dimension2d: public Dimension {
      public:
         Long w;
         Long h;

         Typobj Type() const { return Po_Dimension2d; } 
   
         std::string Name() const { return TypeName< Dimension2d >::Name();  }

         Dimension2d(): Dimension(), w(0), h(0) {}

         Dimension2d( Long height, Long width ): Dimension(), w(width), h(height) {}

         Dimension2d( const Dimension2d& d ): Dimension(), w(d.w), h(d.h) {}

         const Dimension2d& operator=( const Dimension2d& d ) {
            w = d.w;
            h = d.h;

            return *this;
         }
   
         bool operator==( const Dimension2d& d ) const {
            return  d.w == w && d.h == h;
         }

         bool operator!=( const Dimension2d& d ) const {
            return !(d == *this);
         }
   
         Dimension2d operator+( int x ) const {
            return Dimension2d(h + x, w + x);
         }
   
         Dimension2d operator-( int x ) const {
            return Dimension2d(h - x, w - x);
         }

         Dimension2d operator*( int x ) const {
            return Dimension2d(h * x, w * x);
         }
   
         Dimension2d operator/( int x ) const {
            return Dimension2d(h / x, w / x);
         }

         Pobject* Clone() const {
            return new Dimension2d(h, w);
         }   
   
         Errc LoadData( FILE *df ) {
            if (Fdecode(&h, sizeof(h), 1, df) < 1) {
               return FAILURE;
            }
            if (Fdecode(&w, sizeof(w), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }

         Errc SaveData( FILE *df ) const {
            if (this->Fencode(&h, sizeof(h), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fencode(&w, sizeof(w), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   };

   inline const Dimension2d operator*( int x, const Dimension2d &d ) {
      return Dimension2d(d.h * x, d.w * x);
   }
   
   class Dimension3d: public Dimension {
      public:
         Long d;
         Long h;
         Long w;

         Typobj Type() const { return Po_Dimension3d; } 
   
         std::string Name() const { return TypeName< Dimension3d >::Name(); }

         Dimension3d(): Dimension(), d(0), h(0), w(0) {}

         Dimension3d( Long depth, Long height, Long width ): Dimension(), d(depth), h(height), w(width) {}

         Dimension3d( const Dimension3d &d ): Dimension(), d(d.d), h(d.h), w(d.w) {}

         Dimension3d operator=( const Dimension3d &x ) {
            w = x.w; h = x.h; d = x.d;
            return *this;
         }
   
         bool operator==( const Dimension3d &x ) const{
            return x.w == w && x.h == h && x.d == d;
         }
   
         bool operator!=( const Dimension3d &x ) const {
            return !(x == *this);
         }
   
         Dimension3d operator+( int x ) const {
            return Dimension3d(d + x, h + x, w + x);
         }
   
         Dimension3d operator-( int x ) const {
            return Dimension3d(d - x, h - x, w - x);
         }

         Dimension3d operator*( int x ) const {
            return Dimension3d(d * x, h * x, w * x);
         }
         
         Dimension3d operator/( int x ) const {
            return Dimension3d(d / x, h / x, w / x);
         }

         Pobject* Clone() const {
            return new Dimension3d(d, h, w);
         }

         Errc LoadData( FILE *df ) {
            if (this->Fdecode(&d, sizeof(d), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fdecode(&h, sizeof(h), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fdecode(&w, sizeof(w), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }

         Errc SaveData( FILE *df ) const {
            if (this->Fencode(&d, sizeof(d), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fencode(&h, sizeof(h), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fencode(&w, sizeof(w), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   };

   inline const Dimension3d operator*( int x, const Dimension3d &d ) {
      return Dimension3d(d.d * x, d.h * x, d.w * x);
   }

} //End of pandore:: namespace

#endif // __PDIMENSIONH__

---

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