point.cpp

Ugrás a fájl dokumentációjához.

#define _USE_MATH_DEFINES
#include "point.h"
#include <cmath>
 
 
namespace bme {
 
    Point::Point() {
        x = .0;
        y = .0;
    }
 
    Point::Point(double xx, double yy) {
        x = xx;
        y = yy;
    }
 
    double Point::getX()const {
        return x;
    }
 
    double Point::getY()const {
        return y;
    }
 
    void Point::setX(double xx) {
        x = xx;
    }
 
    void Point::setY(double yy) {
        y = yy;
    }
 
    double Point::getR()const {
        return sqrt(x*x+y*y);
    }
 
    void Point::setR(double r) {
        //ha a pont az origó, akkor beállítjuk az (r,0) pontot
        if ((x == 0.) && (y == 0.)) {
            x = r;
            return;
        }
 
        //különben beállítjuk a pontot (r*cos(A),r*sin(A))-ra, 
        //ahol A a pontba mutató vektor és az x tengely által bezárt szög
        double A = getA();
        x = r * cos(A);
        y = r * sin(A);
    }
 
    double Point::getA()const {
        if ((x == 0.) && (y == 0.)) {
            return .0;
        }
 
        double A = atan2(y, x);
        if (A < 0) {
            A += 2 * M_PI;
        }
 
        return A;
    }
 
    void Point::setA(double theta) {
        double r = getR();
        x = r * cos(theta);
        y = r * sin(theta);
    }
 
    void Point::rotate(double theta) {
        double A = getA();
        A += theta;
        setA(A);
    }
 
    bool Point::operator==(const Point& Q)const {
        return ((x == Q.x) && (y == Q.y));
    }
 
    bool Point::operator!=(const Point& Q)const {
        return !((*this) == Q);
    }
 
    Point& Point::operator=(const Point &Q) {
        x = Q.x;
        y = Q.y;
        return *this;
    }
 
    Point Point::operator+(const Point& Q) const{
        return Point(x + Q.x, y + Q.y);
    }
 
    Point Point::operator-(const Point& Q) const {
        return Point(x - Q.x, y - Q.y);
    }
 
    Point Point::operator*(double c) const {
        return Point(c*x, c*y);
    }
 
    Point Point::operator/(double c) const {
        return Point(x/c, y/c);
    }
 
 
    Point& Point::operator+=(const Point& Q) {
        return (*this) = (*this) + Q;
    }
 
    Point& Point::operator-=(const Point& Q) {
        return (*this) = (*this) - Q;
    }
 
    Point& Point::operator*=(double c) {
        return (*this) = (*this) * c;
    }
 
    Point& Point::operator/=(double c) {
        return (*this) = (*this) / c;
    }
 
    double dist(Point P, Point Q) {
        double dx = P.getX() - Q.getX();
        double dy = P.getY() - Q.getY();
        return sqrt(dx * dx + dy * dy);
    }
 
    Point midpoint(Point P, Point Q) {
        return (P+Q)/2.;
    }
 
    ostream& operator<<(ostream& os, const Point& P) {
        os << "(" << P.getX() << "," << P.getY() << ")";
        return os;
    }
 
    Point operator*(double c, const Point& P) {
        return P*c;
    }
}