Point.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  Point.h Two-dimensional integral vector
  Copyright (C) 2014 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef POINT_H
#define POINT_H

#include <stdlib.h>
#include "itype.h"
#include "Random.h"
#include "Util.h"  /* For MAX and MIN */

namespace MFM
{

  template <class T>
  class Point
  {
  private:
    T m_x, m_y;

  public:

    Point();

    Point(T x, T y);

    Point(const Point<T> & p);

    Point(Random& random, T maxX, T maxY);

    ~Point() { }

    T GetX() const;

    T GetY() const;

    u32 GetManhattanLength() const;

    u32 GetMaximumLength() const;

    double GetEuclideanLength() const;

    void Clear()
    {
      m_x = m_y = 0;
    }

    void Add(const Point<T>& offset);

    void Add(T x, T y);

    void Subtract(const Point<T>& offset);

    void Subtract(T x, T y);

    void Multiply(T scalar);

    void Divide(T scalar);

    void Mod(T scalar);

    void SetX(T x);

    void SetY(T y);

    void Set(T x, T y);

    void Set(const Point<T>& copyFrom);

    bool Equals(const Point<T>& rhs) const;

    bool BoundedBelow(const Point<T>& bound) const;

    bool BoundedAbove(const Point<T>& bound) const;

    bool BoundedBy(const Point<T>& lowerBound,const Point<T>& upperBound) const;

    bool IsZero() const
    {
      return m_x == 0 && m_y == 0;
    }

    void Parse(char* buffer);

    friend Point<T> max(const Point<T> & lhs,const Point<T> & rhs)
    {
      T x = MAX(lhs.m_x, rhs.m_x);
      T y = MAX(lhs.m_y, rhs.m_y);
      return Point<T>(x,y);
    }

    friend Point<T> min(const Point<T> & lhs,const Point<T> & rhs)
    {
      T x = MIN(lhs.m_x, rhs.m_x);
      T y = MIN(lhs.m_y, rhs.m_y);
      return Point<T>(x,y);
    }



    Point<T>& operator=(const Point<T> & rhs);

    Point<T>& operator+=(const Point<T> & rhs)
    {
      Add(rhs);
      return *this;
    }

    Point<T>& operator-=(const Point<T> & rhs)
    {
      Subtract(rhs);
      return *this;
    }

    Point<T>& operator*=(const s32 rhs)
    {
      Multiply(rhs);
      return *this;
    }

    Point<T>& operator/=(const s32 rhs)
    {
      Divide(rhs);
      return *this;
    }

    friend Point<T> operator+(const Point<T> & lhs,const Point<T> & rhs)
    {
      Point<T> ret(lhs);
      ret.Add(rhs);
      return ret;
    }

    friend Point<T> operator-(const Point<T> & lhs,const Point<T> & rhs)
    {
      Point<T> ret(lhs);
      ret.Subtract(rhs);
      return ret;
    }

    friend bool operator==(const Point<T> & lhs,const Point<T> & rhs)
    {
      return lhs.Equals(rhs);
    }

    friend bool operator!=(const Point<T> & lhs,const Point<T> & rhs)
    {
      return !(lhs==rhs);
    }

    friend Point<T> operator*(const Point<T> & lhs,const s32 rhs)
    {
      Point<T> ret(lhs);
      ret.Multiply(rhs);
      return ret;
    }

    friend Point<T> operator/(const Point<T> & lhs,const s32 rhs)
    {
      Point<T> ret(lhs);
      ret.Divide(rhs);
      return ret;
    }

    friend Point<T> operator%(const Point<T> & lhs,const s32 rhs)
    {
      Point<T> ret(lhs);
      ret.Mod(rhs);
      return ret;
    }
  };

  typedef Point<s32> SPoint;

  typedef Point<u32> UPoint;

  typedef Point <s16> SSPoint;

  typedef Point <u16> USPoint;

  UPoint MakeUnsigned(const SPoint & spoint);

  inline bool CanMakeUnsigned(const SPoint & spoint)
  {
    return spoint.GetX() >= 0 && spoint.GetY() >= 0;
  }

  SPoint MakeSigned(const UPoint & upoint);

  inline bool CanMakeSigned(const UPoint & upoint)
  {
    return upoint.GetX() <= (u32) S32_MAX && upoint.GetY() <= (u32) S32_MAX;
  }

} /* namespace MFM */

#include "Point.tcc"

#endif /*POINT_H*/