Coord.h

/***************************************************************************
 * file:        Coord.h
 *
 * author:      Christian Frank
 *
 * copyright:   (C) 2004 Telecommunication Networks Group (TKN) at
 *              Technische Universitaet Berlin, Germany.
 *
 *              This program is free software; you can redistribute it
 *              and/or modify it under the terms of the GNU General Public
 *              License as published by the Free Software Foundation; either
 *              version 2 of the License, or (at your option) any later
 *              version.
 *              For further information see file COPYING
 *              in the top level directory
 ***************************************************************************
 * part of:     framework implementation developed by tkn
 **************************************************************************/


#ifndef _COORD_H
#define _COORD_H

#include <omnetpp.h>
#include "FWMath.h"

class Coord : public cObject
{
public:
  static const double UNDEFINED;

protected:
  double x;
    double y;
    double z;
    bool use2DFlag;

public:

    Coord(bool use2D = false)
        :x(0.0), y(0.0), use2DFlag(use2D)
    {

        if (use2D) {
            z = UNDEFINED;
        } else {
            z = 0.0;
        }
    }

    Coord(double x, double y, double z)
        : x(x), y(y), z(z) , use2DFlag(false) {}

    Coord(double x, double y)
        : x(x), y(y), z(UNDEFINED) , use2DFlag(true) {}


    Coord( const Coord& pos )
        : cObject(pos), x(pos.x), y(pos.y), z(pos.z), use2DFlag(pos.use2DFlag) {}

    Coord( const Coord* pos )
        : cObject(*pos), x(pos->x), y(pos->y), z(pos->z), use2DFlag(pos->use2DFlag) {}

    std::string info() const {
        std::stringstream os;
        if (use2DFlag) {
            os << "(" << x << "," << y << ")";
        } else {
            os << "(" << x << "," << y << "," << z << ")";
        }
        return os.str();
    }

    friend Coord operator+(const Coord& a, const Coord& b) {
        Coord tmp = a;
        tmp += b;
        return tmp;
    }

    friend Coord operator-(const Coord& a, const Coord& b) {
        Coord tmp = a;
        tmp -= b;
        return tmp;
    }

    friend Coord operator*(const Coord& a, double f) {
    Coord tmp = a;
    tmp *= f;
        return tmp;
    }

    friend Coord operator/(const Coord& a, double f) {
    Coord tmp = a;
    tmp /= f;
        return tmp;
    }

    Coord operator*=(double f) {
        x *= f;
        y *= f;
        z *= f;
        return *this;
    }

    Coord operator/=(double f) {
        x /= f;
        y /= f;
        z /= f;
        return *this;
    }

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

    Coord operator=(const Coord& a) {
        x = a.x;
        y = a.y;
        z = a.z;
        use2DFlag = a.use2DFlag;
        return *this;
    }

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

    friend bool operator==(const Coord& a, const Coord& b) {
        return FWMath::close(a.x, b.x) && FWMath::close(a.y, b.y) && FWMath::close(a.z, b.z);
    }

    friend bool operator!=(const Coord& a, const Coord& b) {
        return !(a==b);
    }

    double distance( const Coord& a ) const {
        Coord dist=*this-a;
        return dist.length();
    }

    double sqrdist( const Coord& a ) const {
        Coord dist=*this-a;
        return dist.squareLength();
    }

    double sqrTorusDist(const Coord& b, const Coord& playgroundSize) const;

    double squareLength() const
    {
        return x * x + y * y + z * z;
    }

    double length() const
    {
        return sqrt(squareLength());
    }

    double getX() const{ return x; }

    void setX(double x){this->x = x;}

    double getY() const{ return y; }

    void setY(double y){this->y = y;}

    double getZ() const{ return z; }

    void setZ(double z){this->z = z;}

    bool isValid() const {
        return (z == UNDEFINED) || !use2DFlag;
    }

    bool is2D() const { return use2DFlag; }

    bool is3D() const { return !use2DFlag; }

    bool isInRectangle(const Coord& upperLeftCorner, const Coord& lowerRightCorner) const {
        return  x >= upperLeftCorner.x && x <= lowerRightCorner.x &&
                y >= upperLeftCorner.y && y <= lowerRightCorner.y &&
                (use2DFlag || (z >= upperLeftCorner.z && z <= lowerRightCorner.z));
    }

  bool isInBoundary(const Coord& lowerBound, const Coord& upperBound) const {
    return  x >= lowerBound.x && x < upperBound.x &&
        y >= lowerBound.y && y < upperBound.y &&
        (use2DFlag || (z >= lowerBound.z && z < upperBound.z));
  }

    Coord min(const Coord& a) {
        Coord tmp = *this;
  tmp.setX(this->x < a.x ? this->x : a.x);
  tmp.setY(this->y < a.y ? this->y : a.y);
  if (tmp.is3D())
    tmp.setZ(this->z < a.z ? this->z : a.z);
        return tmp;
    }

    Coord max(const Coord& a) {
        Coord tmp = *this;
  tmp.setX(this->x > a.x ? this->x : a.x);
  tmp.setY(this->y > a.y ? this->y : a.y);
  if (tmp.is3D())
    tmp.setZ(this->z > a.z ? this->z : a.z);
        return tmp;
    }

    friend bool operator>(const Coord& a, const Coord& b) {
    return (a.x > b.x
        && a.y > b.y
        && (a.is3D() ? a.z > b.z : true));
    }

    friend bool operator<(const Coord& a, const Coord& b) {
    return (a.x < b.x
        && a.y < b.y
        && (a.is3D() ? a.z < b.z : true));
    }
};

#endif