---

CoordPointUnknown.h

Go to the documentation of this file.

/* -*- Mode: C++ -*-
 * $Id: CoordPointUnknown.h,v 1.7 2002/08/31 14:51:26 s02davro Exp $
 *
 *
 * COPYRIGHT INFORMATION
 *
 * This file is part of RoboSoc created by Fredrik Heintz <frehe@ida.liu.se>
 * Copyright (C) 1999, 2000 Fredrik Heintz, Linköping University, Sweden
 *
 * You are allowed to modify and use this code as long as you retain this
 * notice. If you make any changes or have any comments I would appreciate
 * it if you send me a message. For more information, please see
 * http://www.ida.liu.se/~frehe/RoboCup/RoboSoc/
 *
 *
 * IDENTIFICATION
 *
 * Filename: CoordPointUnknown.h
 * Unitname: Library
 * $Revision: 1.7 $
 * Created by: Fredrik Heintz 1999-xx-xx
 * Last modified by $Author: s02davro $ $Date: 2002/08/31 14:51:26 $
 *
 *
 * HISTORY
 *
 * $Log: CoordPointUnknown.h,v $
 * Revision 1.7  2002/08/31 14:51:26  s02davro
 * Modifications and corrections of point classes.
 *
 * Revision 1.6  2002/08/02 21:33:56  s02davro
 * Added documentation. Restructing.
 *
 * Revision 1.5  2001/08/29 21:08:28  frehe
 * Replaces class T with typename T where T can be a built in type.
 *
 * Revision 1.4  2000/09/18 15:20:05  frehe
 * Due to a problem with namespaces the name for atan2, atan, acos and asin 
 * is changed to ATan2, ATan, ASin and ACos.
 *
 * Revision 1.3  2000/09/04 15:21:49  frehe
 * Changed the name of the trigonometric functions to the same as in the 
 * standard math library (sin, cos, tan, asin, acos, atan, and atan2).
 *
 * Revision 1.2  2000/09/01 03:23:52  frehe
 * Made minor changes.
 *
 * Revision 1.1  2000/09/01 01:24:38  frehe
 * Importet the current version of RoboSoc (soon to be v2.5.0)
 *
 *
 */

#ifndef COORDPOINTUNKNOWN_H
#define COORDPOINTUNKNOWN_H

#include <iostream>

#include "math_utils.h"
#include "AngleDegrees.h"
#include "WithUnknown.h"
#include "CoordPoint.h"
#include "CoordVector.h"
#include "CoordVectorUnknown.h"
#include "UnknownValueException.h"
#include "rs_throw.h"

#define POINTUNKNOWN_HEAD std::string("#PointUnknown")

RS_BEGIN_NAMESPACE

template<typename T> class CoordVectorUnknown;

template<typename T> class CoordPointUnknown {
public:
  CoordPointUnknown();
  
  CoordPointUnknown(const T& x, const T& y);

  CoordPointUnknown(const WithUnknown<T>& x, const WithUnknown<T>& y);

  CoordPointUnknown(const CoordPoint<T>& pt);

  CoordPointUnknown(const CoordPointUnknown<T>& pt);

  CoordPointUnknown(const CoordPoint<T>& pt,
        const CoordVectorUnknown<T>& vec);
  CoordPointUnknown(const CoordPointUnknown<T>& pt,
        const CoordVector<T>& vec);
  CoordPointUnknown(const CoordPointUnknown<T>& pt,
        const CoordVectorUnknown<T>& vec);

  explicit CoordPointUnknown(const CoordVectorUnknown<T>& vec);
  explicit CoordPointUnknown(const CoordVector<T>& vec);
 
  CoordPointUnknown<T>& operator =(const CoordPointUnknown<T>& pt);

  CoordPointUnknown<T> operator- () const;
  CoordPointUnknown<T> operator- (const CoordPointUnknown<T>& pt) const;
  CoordPointUnknown<T> operator- (const CoordVectorUnknown<T>& vec) const;
  CoordPointUnknown<T> operator+ (const CoordPointUnknown<T>& pt) const;
  CoordPointUnknown<T> operator+ (const CoordVectorUnknown<T>& vec) const;
  CoordPointUnknown<T> operator* (const WithUnknown<T>& val) const;
  CoordPointUnknown<T> operator* (const CoordPointUnknown<T>& pt) const;
  CoordPointUnknown<T> operator/ (const WithUnknown<T>& val) const;
  CoordPointUnknown<T> operator/ (const CoordPointUnknown<T>& pt) const;
  CoordPointUnknown<T>& operator-=(const CoordPointUnknown<T>& pt);
  CoordPointUnknown<T>& operator-=(const CoordVectorUnknown<T>& vec);
  CoordPointUnknown<T>& operator+=(const CoordPointUnknown<T>& pt);
  CoordPointUnknown<T>& operator+=(const CoordVectorUnknown<T>& vec);
  CoordPointUnknown<T>& operator*=(const WithUnknown<T>& val);
  CoordPointUnknown<T>& operator*=(const CoordPointUnknown<T>& pt);
  CoordPointUnknown<T>& operator/=(const WithUnknown<T>& val);
  CoordPointUnknown<T>& operator/=(const CoordPointUnknown<T>& pt);

  bool operator ! () const;
  bool operator ==(const CoordPointUnknown<T>& pt) const;
  bool operator !=(const CoordPointUnknown<T>& pt) const;

  CoordPointUnknown<T>& makeUnknown();

  bool isKnown() const;

  bool isUnknown() const;

  CoordPoint<T> getPoint() const throw(UnknownValueException);

  WithUnknown<T> getX() const;

  WithUnknown<T> getY() const;

  CoordPointUnknown<T>& addX(const WithUnknown<T>& pt_x);

  CoordPointUnknown<T>& addY(const WithUnknown<T>& pt_y);

  CoordPointUnknown<T>& addXY(const WithUnknown<T>& pt_x,
            const WithUnknown<T>& pt_y);

  CoordPointUnknown<T>& setX(const WithUnknown<T>& pt_x);

  CoordPointUnknown<T>& setY(const WithUnknown<T>& pt_y);

  CoordPointUnknown<T>& set (const WithUnknown<T>& pt_x, 
           const WithUnknown<T>& pt_y);
  
  CoordVectorUnknown<T> getVectorTo(const CoordPointUnknown<T>& pt) const;

  AngleDegreesUnknown<T> getDirectionTo(const CoordPointUnknown<T>& pt) const;

  WithUnknown<T> getDistanceTo(const CoordPointUnknown<T>& pt) const;
  
protected:
  WithUnknown<T> x;

  WithUnknown<T> y;  
};

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown() {
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const WithUnknown<T>& pt_x, 
          const WithUnknown<T>& pt_y)
  : x(pt_x),
    y(pt_y) {
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const T& pt_x, const T& pt_y)
  : x(pt_x),
    y(pt_y) {
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordPoint<T>& pt)
  : x(pt.getX()),
    y(pt.getY()) {
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordPointUnknown<T>& pt)
  : x(pt.x),
    y(pt.y) {
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordPoint<T>& pt, 
          const CoordVectorUnknown<T>& v) {
  *this = pt + v;
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordPointUnknown<T>& pt, 
          const CoordVector<T>& v) {
  *this = pt + v;
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordPointUnknown<T>& pt, 
          const CoordVectorUnknown<T>& v) {
  *this = pt + v;
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordVector<T>& v) {
  x = v.getLength() * cos(v.getAngle());
  y = v.getLength() * sin(v.getAngle());
}

template<typename T>
CoordPointUnknown<T>::CoordPointUnknown(const CoordVectorUnknown<T>& v) {
  x = v.getLength() * cos(v.getAngle());
  y = v.getLength() * sin(v.getAngle());
}

template<typename T>
CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator =(const CoordPointUnknown<T>& pt) {
  if ( this != &pt ) {
    y = pt.y;
    x = pt.x;
  }
  return *this;
}

template<typename T>
inline bool CoordPointUnknown<T>::isKnown() const {
  return x.isKnown() && y.isKnown();
}

template<typename T>
inline bool CoordPointUnknown<T>::isUnknown() const {
  return x.isUnknown() && y.isUnknown();
}

template<typename T>
CoordPointUnknown<T>& CoordPointUnknown<T>::makeUnknown() {
  x.makeUnknown();
  y.makeUnknown();
  return *this;
}

template <typename T> 
inline CoordPoint<T> 
CoordPointUnknown<T>::getPoint() const throw(UnknownValueException) {
  if ( isUnknown() ) {
    RS_THROW(UnknownValueException, "Tried to take the value of an unknown point");
    return CoordPoint<T>();
  } else
    return CoordPoint<T>(x.getValue(), y.getValue());
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::addX (const WithUnknown<T>& pt_x) {
  x += pt_x;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::addY (const WithUnknown<T>& pt_y) {
  y += pt_y;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::addXY (const WithUnknown<T>& pt_x,
           const WithUnknown<T>& pt_y) {
  x += pt_x;
  y += pt_y;
  return *this;
}

template<typename T>
inline WithUnknown<T> CoordPointUnknown<T>::getX() const {
  return x;
}

template<typename T>
inline WithUnknown<T> CoordPointUnknown<T>::getY() const {
  return y;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::setX(const WithUnknown<T>& pt_x) {
  x = pt_x;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::setY(const WithUnknown<T>& pt_y) {
  y = pt_y;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::set(const WithUnknown<T>& pt_x, 
        const WithUnknown<T>& pt_y) {
  x = pt_x;
  y = pt_y;
  return *this;
}

template<typename T>
AngleDegreesUnknown<T> 
CoordPointUnknown<T>::getDirectionTo(const CoordPointUnknown<T>& pt) const {
  if ( pt.isUnknown() )
    return AngleDegreesUnknown<T>();
  else
    return ATan2((pt.y - y), (pt.x - x));
}

template<typename T>
inline WithUnknown<T> 
CoordPointUnknown<T>::getDistanceTo(const CoordPointUnknown<T>& pt) const {
  return sqrt(sqr(pt.x - x) + sqr(pt.y - y));
}

template<typename T>
CoordVectorUnknown<T> 
CoordPointUnknown<T>::getVectorTo(const CoordPointUnknown<T>& pt) const {
  return CoordVectorUnknown<T>(*this, pt);
}

template<typename T>
inline CoordPointUnknown<T> CoordPointUnknown<T>::operator -() const {
  return CoordPointUnknown<T>(-x,-y);
}

template<typename T>
CoordPointUnknown<T> 
CoordPointUnknown<T>::operator-(const CoordVectorUnknown<T>& v) const {
  return *this + CoordPointUnknown<T>(-v);
}

template<typename T>
inline CoordPointUnknown<T> 
CoordPointUnknown<T>::operator -(const CoordPointUnknown<T>& pt) const {
  return CoordPointUnknown<T>(x - pt.x, y - pt.y);
}

template<typename T>
inline CoordPointUnknown<T> 
CoordPointUnknown<T>::operator +(const CoordPointUnknown<T>& pt) const {
  return CoordPointUnknown<T>(x + pt.x, y + pt.y);
}

template<typename T>
CoordPointUnknown<T> 
CoordPointUnknown<T>::operator+(const CoordVectorUnknown<T>& v) const {
  return *this + CoordPointUnknown<T>(v);
}

template<typename T>
inline CoordPointUnknown<T> 
CoordPointUnknown<T>::operator *(const CoordPointUnknown<T>& pt) const {
  return CoordPointUnknown<T>(x * pt.x, y * pt.y);
}

template<typename T>
inline CoordPointUnknown<T> 
CoordPointUnknown<T>::operator *(const WithUnknown<T>& a) const {
  return CoordPointUnknown<T>(x * a, y * a);
}

template<typename T>
inline CoordPointUnknown<T> 
CoordPointUnknown<T>::operator /(const CoordPointUnknown<T>& pt) const {
#if CHECK_DIVisION_BY_ZERO == 1
  if ( pt.x == T(0) ) {
    if ( pt.y == T(0) ) {
      return CoordPointUnknown_DIVisION_BY_ZERO_RESULT;
    } else {
      return CoordPointUnknown<T>(T_DIVisION_BY_ZERO_RESULT, y / pt.y);
    }
  } else {
    if ( pt.y == T(0) ) {
      return CoordPointUnknown<T>(x / pt.x, T_DIVisION_BY_ZERO_RESULT);
    } else {
#endif
      return CoordPointUnknown<T>(x / pt.x, y / pt.y);
#if CHECK_DIVisION_BY_ZERO == 1      
    }
  }
#endif
}

template<typename T>
inline CoordPointUnknown<T> 
CoordPointUnknown<T>::operator /(const WithUnknown<T>& a) const {
#if CHECK_DIVisION_BY_ZERO == 1
  if (a == T(0))
    return CoordPointUnknown_DIVisION_BY_ZERO_RESULT;
  else
#endif
    return CoordPointUnknown<T>(x / a, y / a);
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator-=(const CoordPointUnknown<T>& pt) {
  x -= pt.x;
  y -= pt.y;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator-=(const CoordVectorUnknown<T>& vec) {
  *this = *this - vec;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator+=(const CoordVectorUnknown<T>& vec) {
  *this = *this + vec;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator+=(const CoordPointUnknown<T>& pt) {
  x += pt.x;
  y += pt.y;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator*=(const WithUnknown<T>& a) {
  x *= a;
  y *= a;
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator*=(const CoordPointUnknown<T>& pt) {
  x *= pt.x;
  y *= pt.y;
  return *this;
}

template<typename T>
CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator/=(const WithUnknown<T>& a) {
#if CHECK_DIVisION_BY_ZERO == 1
  if ( a == T(0)) {
    x = T_DIVisION_BY_ZERO_RESULT;
    y = T_DIVisION_BY_ZERO_RESULT;
  } else {
#endif
    x /= a;
    y /= a;
#if CHECK_DIVisION_BY_ZERO == 1
  }
#endif
  return *this;
}

template<typename T>
inline CoordPointUnknown<T>& 
CoordPointUnknown<T>::operator/=(const CoordPointUnknown<T>& pt) {
#if CHECK_DIVisION_BY_ZERO == 1
  if ( pt.x == T(0) )
    x = T_DIVisION_BY_ZERO_RESULT;
  else
#endif
    x /= pt.x;
  
#if CHECK_DIVisION_BY_ZERO == 1
  if ( pt.y == T(0) )
    y = T_DIVisION_BY_ZERO_RESULT;
  else
#endif
    y /= pt.y;

  return *this;
}

template<typename T>
inline bool CoordPointUnknown<T>::operator !() const {
  return (!y) && (!x);
}

template<typename T>
inline bool 
CoordPointUnknown<T>::operator ==(const CoordPointUnknown<T>& pt) const {
  return (y == pt.y) && (x == pt.x);
}

template<typename T>
inline bool 
CoordPointUnknown<T>::operator !=(const CoordPointUnknown<T>& pt) const {
  return (y != pt.y) || (x != pt.x);
}


template<typename T>
inline CoordPointUnknown<T> operator -(const CoordPoint<T>& pt1,
               const CoordPointUnknown<T>& pt2) {
  return (-pt2) + pt1;
}


template<typename T>
inline CoordPointUnknown<T> operator +(const CoordPoint<T>& pt1,
               const CoordPointUnknown<T>& pt2) {
  return pt2 + pt1;
}

template<typename T>
inline CoordPointUnknown<T> operator *(const T& a,
               const CoordPointUnknown<T>& pt) {
  return pt * a;
}

template<typename T>
inline CoordPointUnknown<T> operator *(const WithUnknown<T>& a,
               const CoordPointUnknown<T>& pt) {
  return pt * a;
}

template<typename T>
inline CoordPointUnknown<T> operator *(const CoordPoint<T>& pt1,
               const CoordPointUnknown<T>& pt2) {
  return pt2 * pt1;
}


template<typename T>
CoordPointUnknown<T> operator /(const CoordPoint<T>& pt1,
        const CoordPointUnknown<T>& pt2) {
  if ( pt2.isUnknown() )
    return CoordPointUnknown<T>();
  else
    return pt1 / pt2.getPoint();
}

template<typename T>
inline bool operator ==(const CoordPoint<T>& pt1,
      const CoordPointUnknown<T>& pt2) {
  return pt2 == pt1;
}

template<typename T>
inline bool operator !=(const CoordPoint<T>& pt1,
      const CoordPointUnknown<T>& pt2) {
  return pt2 != pt1;
}

template<typename T>
inline const std::string toString(const CoordPointUnknown<T>& pt) {
#ifdef POINTUNKNOWN_HEAD
  return POINTUNKNOWN_HEAD + "(" + toString(pt.getX()) + ", " + 
    toString(pt.getY()) + ")";
#else
  return "(" + toString(pt.getX()) + ", " + toString(pt.getY()) + ")";
#endif
}

template<typename T>
inline std::ostream& operator<<(std::ostream& os, 
        const CoordPointUnknown<T>& pt) {
#ifdef POINTUNKNOWN_HEAD
  return os << POINTUNKNOWN_HEAD << "(" << pt.getX() << ", " 
      << pt.getY() << ")";
#else
  return os << "(" << pt.getX() << ", " << pt.getY() << ")";
#endif
}

// Extend this to be the point on the line between pt1 and pt2 
// with a certain ratio 1:1 is the middle point?
template<typename T>
inline CoordPointUnknown<T> middlePoint(const CoordPointUnknown<T>& pt1,
          const CoordPointUnknown<T>& pt2) {
  return pt1 + CoordPointUnknown<T>((pt2.getX() - pt1.getX())/2,
            (pt2.getY() - pt1.getY())/2);
}


RS_END_NAMESPACE


#endif // COORDPOINTUNKNOWN_H

---