geocoordinate.h

Go to the documentation of this file.

#pragma once

#include "cad/const.h"
#include <cmath>
#include <iostream>

namespace lc {
    namespace geo {
        class Coordinate {
            public:
                explicit Coordinate() : _x(0.), _y(0.), _z(0.) {}
                Coordinate(double x, double y, double z) : _x(x), _y(y), _z(z) {}
                Coordinate(double x, double y) : _x(x), _y(y), _z(0.) {}
                explicit Coordinate(double angle) : _x(std::cos(angle)), _y(std::sin(angle)), _z(0.) {}
                Coordinate(Coordinate &&c) noexcept : _x(c._x), _y(c._y), _z(c._z) {}
                Coordinate(const Coordinate &c) : _x(c._x), _y(c._y), _z(c._z) {}


                inline double x() const {
                    return _x;
                }

                inline double y() const {
                    return _y;
                }

                inline double z() const {
                    return _z;
                }


                inline Coordinate& operator = (const Coordinate& coord) {
                    if (this != &coord) {
                        _x = coord._x;
                        _y = coord._y;
                        _z = coord._z;
                    }

                    return *this;
                }

            /*
                void operator = (Coordinate&& coord) {
                    _x = coord._x;
                    _y = coord._y;
                    _z = coord._z;
                }*/

                Coordinate flipXY() const {
                    return Coordinate(this->y(), this->x(), this->z());
                }

                double angleTo(const Coordinate& v) const {
                    return (v - (*this)).angle();
                }

                double angleBetween(const Coordinate& v1, const Coordinate& v2) const;

                inline bool operator==(const Coordinate& coord) const {
                    return this->_x == coord._x && this->_y == coord._y && this->_z == coord._z;
                }

                inline bool operator!=(const Coordinate& coord) const {
                    return this->_x != coord._x || this->_y != coord._y || this->_z != coord._z;
                }

                inline double distanceTo(const geo::Coordinate& c) const {
                    return (*this - c).magnitude();
                }

                inline Coordinate operator + (const Coordinate& coord) const {
                    return Coordinate(_x + coord._x, _y + coord._y, _z + coord._z);
                }

                inline Coordinate operator + (double d) const {
                    return Coordinate(_x + d, _y + d, _z + d);
                }
                
                inline Coordinate operator - (double d) const {
                    return Coordinate(_x - d, _y - d, _z - d);
                }

                inline Coordinate operator - () const {
                    return Coordinate(-_x, -_y, -_z);
                }

                inline Coordinate operator - (const Coordinate& coord) const {
                    return Coordinate(_x - coord._x, _y - coord._y, _z - coord._z);
                }

                inline Coordinate operator * (const Coordinate& coord) const {
                    return Coordinate(_x * coord._x, _y * coord._y, _z * coord._z);
                }

                inline Coordinate operator * (double s) const {
                    return Coordinate(_x * s, _y * s, _z * s);
                }
                inline Coordinate operator / (double s) const {
                    return Coordinate(_x / s, _y / s, _z / s);
                }

                inline double magnitude() const {
                    return std::sqrt(_x * _x + _y * _y + _z * _z);
                }

                inline double angle() const {
                    return std::atan2(_y, _x);
                }


                inline double squared() const {
                    return _x * _x + _y * _y + _z * _z;
                }

                inline double dot(const Coordinate& coord) const {
                    return _x * coord._x + _y * coord._y + _z * coord._z;
                }

                inline double dot(const Coordinate& v1, const Coordinate& v2) const {
                    return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
                }

                inline Coordinate rotate(const Coordinate& angleVector) const {
                    double x0 = _x * angleVector.x() - _y * angleVector.y();
                    double y0 = _x * angleVector.y() + _y * angleVector.x();
                    return Coordinate(x0, y0);
                }

                inline Coordinate rotate(const double& angle) const {
                    return rotate(Coordinate(angle));
                }

                inline Coordinate rotate(const geo::Coordinate& point, const Coordinate& angleVector) const {
                    return point + (*this - point).rotate(angleVector);
                }

                inline Coordinate rotate(const geo::Coordinate& point, const double& angle) const {
                    return rotate(point, Coordinate(angle));
                }

                inline Coordinate rotateByArcLength(const geo::Coordinate& point, double const length) const {
                    double const angle = (length / point.distanceTo(*this));
                    return rotate(point, Coordinate(angle));
                }

                inline Coordinate scale(const double& scale_factor) const {
                    return Coordinate(_x * scale_factor, _y * scale_factor);
                }

                inline  Coordinate scale(const Coordinate& scale_factor) const {
                    return Coordinate(_x * scale_factor.x(), _y * scale_factor.y());
                }

                inline Coordinate scale(const Coordinate& scale_center, const Coordinate& scale_factor) const {
                    return scale_center + ((*this - scale_center) * scale_factor);
                }

                inline Coordinate mid(const Coordinate& other) const {
                    return (other - *this) / 2. + *this;
                }
                inline Coordinate norm() const {
                    auto m = magnitude();
                    return Coordinate(_x / m, _y / m, _z / m);
                }

                inline Coordinate norm(const double f) const {
                    auto m = magnitude() / f;
                    return Coordinate(_x / m, _y / m, _z / m);
                }

                inline Coordinate move(const Coordinate& direction, double d) const {
                    return direction.norm() * d + *this;
                }

                inline Coordinate moveTo(const Coordinate& to, double d) const {
                    return (to - *this).norm() * d + *this;
                }

                inline Coordinate transform2d(double xx, double yx, double xy, double yy, double x0, double y0) {
                    return Coordinate(xx * _x + xy * _y + x0, yx * _x + yy * _y + y0, _z);
                }

                inline Coordinate mirror(const Coordinate& axis1, const Coordinate& axis2) const {
                    Coordinate dir(axis2 - axis1);
                    auto a= dir.squared();
                    auto ret= axis1 + dir* dot(*this- axis1, dir)/a; //projection point
                    return ret + ret - *this;
                }

            private:
                friend std::ostream& operator<<(std::ostream& os, const Coordinate& coordinate) {
                    os << "Coordinate(x=" << coordinate._x << " y=" << coordinate._y << " z=" << coordinate._z << ")";
                    return os;
                }

            private:
                double _x;
                double _y;
                double _z;
        };

        struct CoordinateDistanceSort {
                CoordinateDistanceSort(const Coordinate& distanceFrom) : _distanceFrom(distanceFrom) {
                }

                bool operator()(const Coordinate& left, const Coordinate& right) const {
                    return left.distanceTo(_distanceFrom) < right.distanceTo(_distanceFrom);
                }

                const Coordinate _distanceFrom;
        };

    }
}