point.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 __PPOINTH__
#define __PPOINTH__

namespace pandore {

   class Dimension1d;
   class Dimension2d;
   class Dimension3d;
   class Point1d;
   class Point2d;
   class Point3d;

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

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

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

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

         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 Point1d: public Point {
      public:
         Long x;
   
         Typobj Type() const { return Po_Point1d; } 
   
         std::string Name() const { return TypeName< Point1d >::Name(); }
  
         Point1d(): Point(), x(0) {}

         Point1d( Long x ): Point(), x(x) {}

         Point1d( const Point1d& p ): Point(), x(p.x) {}

         Point1d( const Dimension1d& d ): Point(), x(d.w) {}

         const Point1d& operator=( const Point1d& pt ) {
            x = pt.x;
            return *this;
         }

         bool operator==( const Point1d& pt ) const {
            return  pt.x == x;
         }

         bool operator!=( const Point1d& pt ) const {
            return !(pt == *this);
         }

         Point1d& operator+=( const Point1d& pt ) {
            x += pt.x;
            return *this;
         }

         Point1d& operator-=( const Point1d& pt ) {
            x -= pt.x;
            return *this;
         }

         Point1d& operator*=( const Point1d& pt ) {
            x *= pt.x;
            return *this;
         }

         Point1d& operator/=( const Point1d& pt ) {
            x /= pt.x;
            return *this;
         }
   
         Point1d operator+( const Point1d& pt ) const {
            return Point1d(x + pt.x);
         }

         Point1d operator-( const Point1d& pt ) const {
            return Point1d(x - pt.x);
         }

         Point1d operator*( const Point1d& pt ) const {
            return Point1d(x * pt.x);
         }

         Point1d operator/( const Point1d& pt ) const {
            return Point1d(x / pt.x);
         }
   
         Pobject* Clone() const {
            return new Point1d(x);
         }
   
         Errc LoadData( FILE *df ) {
            if (this->Fdecode(&x, sizeof(x), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
  
         Errc SaveData( FILE *df ) const {
            if (this->Fencode(&x, sizeof(x), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   };

   class Point2d: public Point {
      public:
         Long x;
         Long y;

         Typobj Type() const { return Po_Point2d; } 
   
         std::string Name() const { return TypeName< Point2d >::Name(); }
   
         Point2d(): Point(), x(0), y(0) {}

         Point2d( Long i ): Point(), x(i), y(i) {}

         Point2d( Long y, Long x ): Point(), x(x), y(y) {}

         Point2d( const Point2d& p): Point(), x(p.x), y(p.y) {}

         Point2d( const Dimension2d& p): Point(), x(p.w), y(p.h) {}

         const Point2d& operator=( const Point2d& pt ) {
            x = pt.x;
            y = pt.y;
            return *this;
         }

         bool operator==( const Point2d& pt ) const {
            return  pt.x == x && pt.y == y;
         }

         bool operator!=( const Point2d& pt ) const {
            return !(pt == *this);
         }
   
         Point2d& operator+=( const Point2d& pt ) {
            x += pt.x;
            y += pt.y;
         return *this;
         }

         Point2d& operator-=( const Point2d& pt ) {
            x -= pt.x;
            y -= pt.y;
            return *this;
         }

         Point2d& operator/=( const Point2d& pt ) {
            x /= pt.x;
            y /= pt.y;
            return *this;
         }

         Point2d& operator*=( const Point2d& pt ) {
            x *= pt.x;
            y *= pt.y;
            return *this;
         }

         Point2d operator+( const Point2d& pt ) const {
            return Point2d(y + pt.y, x + pt.x);
         }
   
         Point2d operator-( const Point2d& pt ) const {
            return Point2d(y - pt.y, x - pt.x);
         }
   
         Point2d operator*( const Point2d& pt ) const {
            return Point2d(y * pt.y, x * pt.x);
         }

         Point2d operator/( const Point2d& pt ) const {
            return Point2d(y / pt.y, x / pt.x);
         }

         Pobject* Clone() const {
            return new Point2d(y, x);
         }

         Errc LoadData( FILE *df ) {
            if (Fdecode(&y, sizeof(y), 1, df) < 1) {
               return FAILURE;
            }
            if (Fdecode(&x, sizeof(x), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }

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

   class Point3d: public Point {
      public:
         Long z;
         Long y;
         Long x;

         Typobj Type() const { return Po_Point3d; } 
   
         std::string Name() const { return TypeName< Point3d >::Name(); }
  
         Point3d(): Point(), z(0), y(0), x(0) {}

         Point3d( Long i ): Point(), z(i), y(i), x(i) {}

         Point3d( Long z, Long y, Long x ): Point(), z(z), y(y), x(x) {}

         Point3d( const Dimension3d& p): Point(), z(p.d), y(p.h), x(p.w) {}

         Point3d( const Point3d& p): Point(), z(p.z), y(p.y), x(p.x) {}

         Point3d operator=( Point3d pt ) {
            x = pt.x;
            y = pt.y;
            z = pt.z;
            return *this; }
   
         bool operator==( const Point3d& pt ) const {
            return pt.x == x && pt.y == y && pt.z == z;
         }
         
         bool operator!=( const Point3d& pt ) const {
            return !(pt == *this);
         }

         Point3d& operator+=( const Point3d& pt ) {
            x += pt.x;
            y += pt.y;
            z += pt.z;
         return *this;
         }

         Point3d& operator-=( const Point3d& pt ) {
            x -= pt.x;
            y -= pt.y;
            z -= pt.z;
            return *this;
         }

         Point3d& operator*=( const Point3d& pt ) {
            x *= pt.x;
            y *= pt.y;
            z *= pt.z;
            return *this;
         }

         Point3d& operator/=( const Point3d& pt ) {
            x /= pt.x;
            y /= pt.y;
            z /= pt.z;
            return *this;
         }

         Point3d operator+( const Point3d& pt ) const { 
            return Point3d(z + pt.z, y + pt.y, x + pt.x); 
         }
   
         Point3d operator-( const Point3d& pt ) const {
            return Point3d(z - pt.z, y - pt.y, x - pt.x);
         }
   
         Point3d operator*( const Point3d& pt ) const {
            return Point3d(z * pt.z, y * pt.y, x * pt.x);
         }
   
         Point3d operator/( const Point3d& pt ) const {
            return Point3d(z / pt.z, y / pt.y, x / pt.x);
         }

         Pobject* Clone() const {
            return new Point3d(z, y, x);
         }

         Errc LoadData( FILE *df ) {
            if (this->Fdecode(&z, sizeof(z), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fdecode(&y, sizeof(y), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fdecode(&x, sizeof(x), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }

         Errc SaveData( FILE *df ) const {
            if (this->Fencode(&z, sizeof(z), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fencode(&y, sizeof(y), 1, df) < 1) {
               return FAILURE;
            }
            if (this->Fencode(&x, sizeof(x), 1, df) < 1) {
               return FAILURE;
            }
            return SUCCESS;
         }
   };
   
} //End of pandore:: namespace

#endif // __PPOINTH__

---

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