a_point.h

Go to the documentation of this file.

/*
         Copyright 2010-2020 Pierre SMARS (smars@yuntech.edu.tw)
         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.
 
         This program 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 General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
         */
#ifndef _A_POINT_H_
#define _A_POINT_H_
 
#include "a_geom_base.h"
#include <stdlib.h>
#include <cmath>
#include "a_mat_sq.h"
 
class a_point;
 
a_point operator+(const a_point& a, const a_point& b);
a_point operator-(const a_point& a, const a_point& b);
double operator*(const a_point& a, const a_point& b);
a_point operator*(const double v, const a_point& a);
a_point operator*(const a_point& a, double v);
a_point cross(const a_point& a, const a_point& b);
a_point operator/(const a_point& a, double v);
a_point circle_centre(const a_point&, const a_point&, const a_point&);
 
class a_point: public a_geom_base
{
        public:
                a_point() = default; 
                a_point(double x, double y, double z) : x_(x), y_(y), z_(z) {}
                a_point(const float x[3]) : x_(x[0]), y_(x[1]), z_(x[2]) {}
                a_point(const double x[3]) : x_(x[0]), y_(x[1]), z_(x[2]) {}
                inline a_point(const a_point& p) {x_ = p.x_; y_ = p.y_; z_ = p.z_;}
 
                virtual const std::string classname() { return "a_point";}
                static const std::string help();
                //: get coordinates
                inline double x() const { return x_; }
                inline double y() const { return y_; }
                inline double z() const { return z_; }
                inline double operator[](const int i) const {if (i==0) return x_; if (i==1) return y_; if (i==2) return z_; exit(1); return x_;}
 
                //: set coordinates
                inline void x(double v) { x_ = v; }
                inline void y(double v) { y_ = v; }
                inline void z(double v) { z_ = v; }
                inline void     set(double x, double y, double z) {x_ = x; y_ = y; z_ = z;}
                inline void     set(double x[3]) {x_ = x[0]; y_ = x[1]; z_ = x[2];}
                inline void     set(float x[3]) {x_ = x[0]; y_ = x[1]; z_ = x[2];}
                a_mat_sq inertia() const;
                inline void     set_cylindrical(double r, double a, double h) {x_ = r*cos(a); y_ = r*sin(a); z_ = h;}
                inline void     set_spherical(double r, double th, double ph) {x_ = r*cos(th)*cos(ph); y_ = r*cos(th)*sin(ph); z_ = r*sin(th);}
                inline void     clear() {this->set(0.,0.,0.);}
                inline a_point& translate(double x, double y, double z) {x_ += x; y_ += y; z_ += z; return *this;}
                a_point& rotate(const a_point& x_axis, const a_point& y_axis, const a_point& z_axis);
                a_point& rotate(const a_point& axis, const double angle);
                inline double& operator[](const int i)  {if (i==0) return x_; if (i==1) return y_; if (i==2) return z_; exit(1); return x_;}
 
                bool operator==(const a_point& p) const;
                bool operator!=(const a_point& p) const {return !this->operator==(p);}
                a_point& operator=(const a_point& p);
                a_point& operator-();
                a_point operator+(const a_point&);
                a_point operator-(const a_point&);
                double operator*(const a_point&);
                a_point cross(const a_point&) const;
                // a_point operator*(double v);
                a_point& operator+=(const a_point&);
                a_point& operator-=(const a_point&);
                double   operator*=(const a_point&);
                a_point& operator*=(double v);
                a_point& operator/=(double v);
 
                a_point& operator/=(const a_point&);
                double sumsq() const;
                double norm() const;
                double norm1() const;
                double norm2() const;
                double normI() const;
                inline double dist(const a_point& p) const {return (p-*this).norm();}
                a_point& normalise();
                a_point& max();
 
                //: input/output
                virtual void read(std::istream &i);
                virtual void write(std::ostream &o) const;
 
        protected:
                double   x_ = 0.; 
                double   y_ = 0.; 
                double   z_ = 0.; 
};
 
inline double dist(const a_point& a, const a_point& b) {return (a-b).norm();}
double angle(a_point a, a_point b);
inline a_point average(const a_point& a, const a_point& b, double f = 0.5) {return (a+f*(b-a));}
a_point average_rot(const a_point& a, const a_point& b, double f = 0.5);
 
#endif